Method build

src/build.rs:313–366

(manifest: &BuildManifest)

            entry: manifest.entry.clone(),
            stdlib: manifest.stdlib,
            import_closure: manifest.import_closure,
            root: manifest.root.name().to_owned(),
            extra_objects: manifest
                .extra_objects
                .iter()
                .map(|object| object.name.clone())
                .collect(),
            abi_exports: manifest.abi_exports.clone(),
            has_source_prelude: manifest.source_prelude.is_some(),
        }
    }

    pub fn build(manifest: &BuildManifest) -> Result<BuildArtifacts, BuildError> {
        let plan = Self::plan(manifest);
        let mut units: Vec<BuiltUnit> = Vec::new();

        for (name, assembled) in Self::compile_stdlib(manifest)? {
            units.push(BuiltUnit { name, assembled });
        }

        for object in &manifest.extra_objects {
            units.push(BuiltUnit {
                name: object.name.clone(),
                assembled: object.assembled.clone(),
            });
        }

        let root = manifest.root.load()?;
        let mut pipeline = Self::pipeline_for(manifest);
        pipeline.set_current_source_path(root.source_path.clone());

        match manifest.import_closure {
            ImportClosurePolicy::Enabled { mangle_symbols } => {
                pipeline.set_module_mangling(mangle_symbols);
                for (name, mut assembled) in pipeline
                    .compile_program_closure(&root.name, &root.source)
                    .map_err(BuildError::Compile)?
                {
                    if name == root.name {
                        Self::mark_abi_exports(manifest, &mut assembled);
                    }
                    units.push(BuiltUnit { name, assembled });
                }
            }
            ImportClosurePolicy::Disabled => {
                let mut root_unit = Self::compile_one(&mut pipeline, &root)?;
                Self::mark_abi_exports(manifest, &mut root_unit.assembled);
                units.push(root_unit);
            }
        }

        let modules: Vec<(&str, &AssembledOutput)> = units
            .iter()
            .map(|unit| (unit.name.as_str(), &unit.assembled))
            .collect();
        let link_pipeline = Self::pipeline_for(manifest);
        let linked = link_pipeline