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)

            Ok(assembled) => (Some(BinaryOutput { assembled }), None),
            Err(e) => (None, Some(PipelineFailure::Linker(e))),
        };

        PipelineResult {
            diagnostics,
            lex,
            parse,
            ir,
            asm,
            binary,
            failure,
        }
    }

    /// Compile an IR program to RISC-V assembly text.
    #[track_caller]
    pub fn compile_ir_to_assembly(&self, ir: &IrProgram) -> Result<String, CodegenError> {
        self.compile_ir_to_assembly_with_tokens(ir)
            .map(|(assembly, _)| assembly)
    }

    /// Compile an IR program to assembly text and the structured token stream.
    #[track_caller]
    pub fn compile_ir_to_assembly_with_tokens(
        &self,
        ir: &IrProgram,
    ) -> Result<(String, Vec<RvInstruction>), CodegenError> {
        let mut compiler = CompilerRv64::new();
        compiler.set_peephole(self.peephole);
        compiler.set_register_allocation(self.register_allocation);
        compiler.set_omit_frame_pointer(self.omit_frame_pointer);
        let (asm, tokens) = compiler.compile_with_tokens(ir)?;
        let stem = if let Some(existing) = self.current_artifact_stem() {
            existing
        } else {
            let stem = self.default_artifact_stem(Location::caller(), "asm", &asm);
            *self.last_artifact_stem.borrow_mut() = Some(stem.clone());
            stem
        };
        self.write_text_artifact("asm", &stem, ".s", &asm);
        Ok((asm, tokens))
    }

    /// Assemble a token stream into machine code.
    #[track_caller]
    pub fn assemble(&self, tokens: &[RvInstruction]) -> Result<AssembledOutput, AssemblerError> {
        let stem = self.current_artifact_stem().unwrap_or_else(|| {
            self.default_artifact_stem(Location::caller(), "obj", &format!("{}", tokens.len()))
        });
        self.assemble_named(&stem, tokens)
    }

    #[track_caller]
    pub fn assemble_named(
        &self,
        stem: &str,
        tokens: &[RvInstruction],
    ) -> Result<AssembledOutput, AssemblerError> {
        let mut assembled = Assembler::assemble(tokens)?;