Method resolve_modules

src/compilation_pipeline.rs:455–555

Resolve `source`'s module imports. Each `alias := import("path")` adds its exported interface to the prelude and yields an export set for qualified access.

(&self, source: &str)

    fn resolve_modules(&self, source: &str) -> Result<ResolvedModules, Vec<Diagnostic>> {
        let mut prelude = String::new();
        let mut aliases: std::collections::HashMap<String, hll_to_ir::imports::ModuleAlias> =
            std::collections::HashMap::new();
        // Import aliases are namespace handles, not symbol definitions, so they never
        // conflict with a same-named export such as `klog := import("klog")`.

        // An unparseable root skips resolution; the compiler reports it with a span.
        let Ok(mut local_names) = hll_to_ir::imports::collect_declaration_names(source) else {
            return Ok(ResolvedModules {
                prelude: None,
                aliases: std::collections::HashMap::new(),
            });
        };
        for (alias, _) in hll_to_ir::imports::collect_module_imports(source)
            .map_err(|msg| vec![Diagnostic::new(DiagnosticLevel::Error, msg)])?
        {
            local_names.remove(&alias);
        }
        let mut imported_exports: std::collections::HashMap<String, String> =
            std::collections::HashMap::new();

        if self.module_resolver.is_some() || self.current_source_path.is_some() {
            let module_imports = hll_to_ir::imports::collect_module_imports(source)
                .map_err(|msg| vec![Diagnostic::new(DiagnosticLevel::Error, msg)])?;
            for (alias, path) in module_imports {
                if aliases.contains_key(&alias) {
                    return Err(vec![Diagnostic::new(
                        DiagnosticLevel::Error,
                        format!("duplicate module import alias `{alias}`"),
                    )]);
                }
                let resolved = self
                    .resolve_module_source(&path, self.current_source_path.as_deref())
                    .map_err(|msg| vec![Diagnostic::new(DiagnosticLevel::Error, msg)])?
                    .ok_or_else(|| {
                        let key = Self::module_key(&path);
                        vec![Diagnostic::new(
                            DiagnosticLevel::Error,
                            format!("cannot resolve import(\"{path}\"): no module named `{key}`"),
                        )]
                    })?;
                let exports =
                    hll_to_ir::imports::collect_exports(&resolved.source).map_err(|msg| {
                        vec![Diagnostic::new(
                            DiagnosticLevel::Error,
                            format!("failed to read exports of \"{path}\": {msg}"),
                        )]
                    })?;
                // Interfaces and generic templates: prefixed like exports, but not link symbols.
                let namespaced = hll_to_ir::imports::collect_exported_interfaces(&resolved.source)
                    .map_err(|msg| {
                        vec![Diagnostic::new(
                            DiagnosticLevel::Error,
                            format!("failed to read interfaces of \"{path}\": {msg}"),
                        )]
                    })?;
                // Only modules the closure itself compiles are mangled. Stdlib modules are
                // precompiled flat and skipped by the closure, so importing one resolves flat.
                let mangle_this = self.mangle_modules && !resolved.is_stdlib;