Method compile

src/compilation_pipeline.rs:697–765

(&self, source: &str)

    #[cfg(not(target_arch = "wasm32"))]
    fn write_bytes_artifact(&self, subdir: &str, stem: &str, extension: &str, bytes: &[u8]) {
        if !self.write_artifacts {
            return;
        }
        let path = self
            .artifact_root
            .join(subdir)
            .join(format!("{stem}{extension}"));
        if let Some(parent) = path.parent()
            && let Err(err) = fs::create_dir_all(parent)
        {
            log::warn!(
                "failed to create artifact directory `{}`: {err}",
                parent.display()
            );
            return;
        }
        if let Err(err) = fs::write(&path, bytes) {
            log::warn!("failed to write artifact `{}`: {err}", path.display());
        }
    }

    #[cfg(target_arch = "wasm32")]
    fn write_text_artifact(&self, _subdir: &str, _stem: &str, _extension: &str, _content: &str) {}

    #[cfg(target_arch = "wasm32")]
    fn write_bytes_artifact(&self, _subdir: &str, _stem: &str, _extension: &str, _bytes: &[u8]) {}

    /// Source -> tokens -> AST -> IR, with mode-specific validation.
    #[track_caller]
    pub fn compile(&self, source: &str) -> Result<CompilationResult, CompilationError> {
        log::info!("Starting compilation pipeline");

        let resolved = self
            .resolve_modules(source)
            .map_err(CompilationError::DiagnosticErrors)?;
        let compiler = HllCompiler::new(CompileConfig {
            target: self.target_mode,
            strict: self.run_semantic_analysis,
            string_prefix: self.string_prefix.clone(),
            type_prelude: self.type_prelude.clone(),
            source_prelude: resolved.prelude,
            module_aliases: resolved.aliases,
            module_mangle_prefix: self
                .mangle_modules
                .then(|| self.current_module_prefix.clone())
                .flatten(),
            source_file: self.config_source_file(),
        });

        let mut out = compiler
            .compile(source)
            .map_err(CompilationError::DiagnosticErrors)?;
        optimize_ir(&mut out.ir, self.optimize);

        // Entry-point presence check for freestanding builds.
        // Kernel mode skips this: `_kernel_start` is provided by the kernel stdlib, not user code.
        if self.target_mode == TargetMode::Freestanding {
            let entry = self.effective_entry_point();