Function package_aot_artifacts

xtask/src/main.rs:8866–8940

(
    target: &str,
    outputs: &BuildOutputs,
    sources: &SourcesManifest,
)

}

fn package_aot_artifacts(
    target: &str,
    outputs: &BuildOutputs,
    sources: &SourcesManifest,
) -> Result<()> {
    let source_dir = Path::new("assets/wasix-build/build/aot").join(target);
    if !source_dir.exists() {
        bail!(
            "AOT source directory {} is missing; run `cargo run -p xtask -- assets aot --target-triple {target}` before packaging",
            source_dir.display()
        );
    }

    let artifacts_dir = generated_aot_dir(target);
    if artifacts_dir.exists() {
        fs::remove_dir_all(&artifacts_dir)
            .with_context(|| format!("remove {}", artifacts_dir.display()))?;
    }
    fs::create_dir_all(&artifacts_dir)
        .with_context(|| format!("create {}", artifacts_dir.display()))?;

    let mut manifest_artifacts = Vec::new();
    for module in &outputs.modules {
        let name = module.name.as_str();
        let file = module.aot_file.as_str();
        let source = source_dir.join(file);
        if !source.exists() {
            bail!(
                "missing AOT artifact {}; run AOT generation for target {target} before packaging",
                source.display()
            );
        }
        let destination = artifacts_dir.join(file);
        copy_file(&source, &destination)?;
        let raw_artifact = decode_zstd_file(&destination)
            .with_context(|| format!("decode AOT artifact {}", destination.display()))?;
        let module_sha256 = outputs
            .modules
            .iter()
            .find(|module| module.name == name)
            .map(|module| sha256_file(&module.path))
            .transpose()?
            .ok_or_else(|| anyhow!("missing build output module {name} for AOT manifest"))?;
        manifest_artifacts.push(AotManifestArtifact {
            name: name.to_owned(),
            path: file.to_owned(),
            sha256: sha256_file(&destination)?,
            raw_sha256: sha256_bytes(&raw_artifact),
            raw_size: raw_artifact.len() as u64,
            module_sha256,
            compressed: true,
        });
    }
    ensure!(
        !manifest_artifacts.is_empty(),
        "AOT packaging produced an empty manifest for {target}"
    );