}

/// Lower all packages into a single IL program.

/// Dependencies are lowered first, then the entry package.

unsafe fn lowerAllPackages 'arena (

    res: *unsafe mut resolver::Resolver 'arena

) -> il::Program throws (Error) {

    let entryIdx = ctx.entryPkgIdx else {

        panic "lowerAllPackages: no entry package";

    };

    }

    try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);

}

/// Run the resolver on the parsed modules.

    let entryPkg = try getEntryPackage(ctx);

    pkgLog(&entryPkg, &["resolving", ".."]);

    let nodeDataSize = nodeCount * @sizeOf(resolver::NodeData);

    }

}

/// Lower all packages while streaming each lowered function into RV64 codegen.

unsafe fn lowerAndGenerateAllPackages 'arena (

    res: *unsafe mut resolver::Resolver 'arena,

    fnArena: &mut alloc::Arena,

    codegenOptions: CodegenOptions

) -> rv64::Program throws (Error) {

    let entryIdx = ctx.entryPkgIdx else {

    return PackageExports { count, entry: entryName };

}

/// Emit one binary RIL file per package into an existing directory.

unsafe fn emitPackages 'arena (

    res: *unsafe mut resolver::Resolver 'arena,

    directory: *[u8]

) throws (Error) {

    for i in 0..ctx.packageCount {

        if ctx.inputs[i].asmPathCount > 0 or ctx.inputs[i].startupPath <> nil {

    return suffix.len > 2 and suffix[0] == ':' and suffix[1] == ':';

}

/// Lower, optionally dump, and optionally generate binary output.

unsafe fn compile 'arena (

    res: *unsafe mut resolver::Resolver 'arena,

    fnArena: &mut alloc::Arena

) throws (Error) {

    let entryPkg = try getEntryPackage(ctx);

    if let directory = ctx.rilDirectory {

            return 1;

        };

    }

    // Run resolution phase.

    let mut mainArena = alloc::new(&mut MAIN_ARENA[..]);

            return 1;

        };

        let mut fnArena = alloc::new(&mut FN_ARENA[..]);

        // Lower, dump, and/or generate output.

            return 1;

        };

        return 0;

    }

}

    nodeData: NodeDataTable,

    /// Linked list of interned types.

    types: ?*TypeNode,

    /// Diagnostics recorded so far.

    errors: DiagnosticBuffer,

    /// Cache of module scopes indexed by module ID.

    moduleScopes: [?*unsafe mut Scope; module::MAX_MODULES],

    /// Trait instance registry.

    instances: [InstanceEntry; MAX_INSTANCES],

    /// Number of registered instances.

        config,

        arena,

        nodeData: NodeDataTable { entries: nodeData },

        types: nil,

        errors: DiagnosticBuffer { entries: errors, len: 0 },

        moduleScopes,

        instances: undefined,

        instancesLen: 0,

        methods: undefined,

        methodsLen: 0,

    return ModuleScope { root: owner, entry: module, newScope: scope, prevScope, prevMod };

}

/// Enter a sub-module. Changes the current scope into that of the sub-module.

unsafe fn enterSubModule 'arena (self: &mut Resolver 'arena, name: *[u8], node: *ast::Node) -> ModuleScope throws (ResolveError) {

        else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));

    let modRoot = module::astFor(modEntry)

        else panic "enterSubModule: analyzing module that wasn't parsed";

    return enterModuleScope(self, modRoot, modEntry);

            return nil;

        }

    }

}

/// Get the parent module scope for the current module.

/// Returns the scope of the parent module, or `nil` if this is a root module.

        else throw emitError(self, node, ErrorKind::Internal);

    let parentId = currentMod.parent

        else return nil; // No parent module.

    return self.moduleScopes[parentId as u32];

    });

}

/// Check whether an attributed module or import is active in this build.

/// A test module is active only when its source module was registered.

    if let attributes = attrs {

        if ast::attributesContains(&attributes, ast::Attribute::Test) {

            if not self.config.buildTest {

                return false;

            }

            if let moduleName = name {

            }

        }

    }

    return true;

}

        try resolveNominalApplications(self, stmt);

    }

}

/// Resolve all packages.

export unsafe fn resolve 'arena (self: &mut Resolver 'arena, graph: &module::ModuleGraph, packages: &[Pkg]) -> Diagnostics throws (ResolveError) {

    // 1. Bind all package roots to enable cross-package references.

    for i in 0..packages.len {

        let pkg = packages[i];

        // Enter a new scope for the module.

/// Print a single diagnostic entry.

unsafe fn printError 'arena (err: &super::Error, res: &super::Resolver 'arena) {

    if let node = err.node {

        // Find the module containing this error.

            // Get the source text if available.

            if let source = module::sourceFor(moduleEntry) {

                // Convert offset to location.

                if let loc = scanner::getLocation(scanner::SourceLoc::File(moduleEntry.filePath), source, node.span.offset) {

                    // Print: filename:line:col: error: message

        let enabled = try resolveProgramStr(&mut a, source);

        try testing::expect(enabled.diagnostics.errors.len > 0);

    }

}

/// Resolver metadata retains its caller's arena when the context moves.

unsafe fn relocateResolver 'arena (context: super::Resolver 'arena) -> super::Resolver 'arena {

    return context;

}