Method compile

src/compilation_pipeline.rs:697–765

(&self, source: &str)

        for (_alias, path) in module_imports {
            let resolved = self
                .resolve_module_source(&path, source_path.as_deref())
                .map_err(|msg| CompilationError::FreestandingErrors(vec![msg]))?
                .ok_or_else(|| {
                    let key = Self::module_key(&path);
                    CompilationError::FreestandingErrors(vec![format!(
                        "cannot resolve import(\"{path}\"): no module named `{key}`"
                    )])
                })?;
            // Stdlib modules are precompiled separately; header-only modules (e.g. `layout`)
            // produce no object and reach the importer through the prepended interface.
            if resolved.is_stdlib
                || !hll_to_ir::imports::defines_code(&resolved.source)
                    .map_err(|msg| CompilationError::FreestandingErrors(vec![msg]))?
            {
                continue;
            }
            self.collect_import_closure(
                &resolved.key,
                &resolved.source,
                resolved.source_path,
                order,
                visited,
                stack,
                stack_keys,
                stack_sources,
            )?;
        }

        stack.pop();
        stack_keys.pop();
        stack_sources.pop();
        visited.insert(name.to_owned());
        order.push((name.to_owned(), source.to_owned(), source_path));
        Ok(())
    }

    /// Compile the stdlib for `mode` as independent per-module objects (no source
    /// concatenation), to link alongside the user program. Kernel gets its prefix.
    pub fn compile_stdlib_objects(
        mode: TargetMode,
    ) -> Result<Vec<(String, AssembledOutput)>, CompilationError> {
        let mut pipeline = CompilationPipeline::new();
        pipeline.set_target_mode(mode);
        pipeline.set_write_artifacts(false);
        pipeline.set_string_prefix(Some(
            if mode == TargetMode::Kernel {
                "__kern_"
            } else {
                "__stdlib_"
            }
            .to_owned(),
        ));
        let modules = hll_to_ir::stdlib::get_stdlib_modules_for_mode(mode);
        let mut objects = Vec::with_capacity(modules.len());
        for (module_name, source) in &modules {
            // Attribute each module to its real source file so stdlib code the
            // debugger steps through maps back to workspace lines.
            let path = hll_to_ir::stdlib::stdlib_module_source_path(mode, module_name);