wit-bindgen-test 0.56.0

Backend of the `wit-bindgen test` subcommand
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::{LanguageMethods, Runner};
use anyhow::{Context, bail};
use serde::Deserialize;
use std::process::Command;

/// MoonBit configuration of project files
#[derive(Default, Deserialize)]
#[serde(deny_unknown_fields)]
struct LangConfig {
    #[serde(default)]
    path: String,
    #[serde(default)]
    pkg_config: Option<String>,
}

pub struct MoonBit;

impl LanguageMethods for MoonBit {
    fn display(&self) -> &str {
        "moonbit"
    }

    fn comment_prefix_for_test_config(&self) -> Option<&str> {
        Some("//@")
    }

    fn default_bindgen_args(&self) -> &[&str] {
        &[
            "--derive-debug",
            "--derive-show",
            "--derive-eq",
            "--derive-error",
        ]
    }

    fn prepare(&self, runner: &mut Runner) -> anyhow::Result<()> {
        println!("Testing if MoonBit toolchain exists...");
        if runner
            .run_command(Command::new("moon").arg("version"))
            .is_err()
        {
            bail!("MoonBit toolchain not found. Check out <https://www.moonbitlang.com/download>");
        }
        Ok(())
    }

    fn compile(&self, runner: &Runner, compile: &crate::Compile) -> anyhow::Result<()> {
        let config = compile.component.deserialize_lang_config::<LangConfig>()?;
        // Copy the file to the bindings directory
        if !config.path.is_empty() {
            let src_path = &compile.component.path;
            let dest_path = compile.bindings_dir.join(&config.path);
            std::fs::copy(src_path, dest_path)?;

            // Write the moon.pkg.json if provided
            if let Some(pkg_config) = config.pkg_config {
                let dest_path = compile
                    .bindings_dir
                    .join(&config.path)
                    .parent()
                    .unwrap()
                    .join("moon.pkg.json");
                std::fs::write(dest_path, pkg_config)?;
            }
        }

        // Compile the MoonBit bindings to a wasm file
        let mut cmd = Command::new("moon");
        cmd.arg("build")
            .arg("--target")
            .arg("wasm")
            .arg("--release")
            .arg("--no-strip") // for debugging
            .current_dir(&compile.bindings_dir);
        runner.run_command(&mut cmd)?;
        // Build the component. MoonBit toolchains may use either `_build` or
        // `target` output roots depending on version/configuration.
        let artifact_candidates = [
            compile
                .bindings_dir
                .join("_build/wasm/release/build/gen/gen.wasm"),
            compile
                .bindings_dir
                .join("target/wasm/release/build/gen/gen.wasm"),
            compile
                .bindings_dir
                .join("_build/wasm/debug/build/gen/gen.wasm"),
            compile
                .bindings_dir
                .join("target/wasm/debug/build/gen/gen.wasm"),
        ];
        let artifact = artifact_candidates
            .iter()
            .find(|path| path.exists())
            .cloned()
            .with_context(|| {
                format!("failed to locate MoonBit output wasm, looked in: {artifact_candidates:?}",)
            })?;
        // Embed WIT files
        let manifest_dir = compile.component.path.parent().unwrap();
        let embedded = artifact.with_extension("embedded.wasm");
        let mut cmd = Command::new("wasm-tools");
        cmd.arg("component")
            .arg("embed")
            .args(["--encoding", "utf16"])
            .args(["-o", embedded.to_str().unwrap()])
            .args(["-w", &compile.component.bindgen.world])
            .arg(manifest_dir)
            .arg(&artifact);
        runner.run_command(&mut cmd)?;
        // Componentize the Wasm
        let mut cmd = Command::new("wasm-tools");
        cmd.arg("component")
            .arg("new")
            .args(["-o", compile.output.to_str().unwrap()])
            .arg(&embedded);
        runner.run_command(&mut cmd)?;
        Ok(())
    }

    fn should_fail_verify(
        &self,
        name: &str,
        config: &crate::config::WitConfig,
        _args: &[String],
    ) -> bool {
        // async-resource-func actually works, but most other async tests
        // fail during codegen or verification
        config.async_ && name != "async-resource-func.wit"
    }

    fn verify(&self, runner: &Runner, verify: &crate::Verify) -> anyhow::Result<()> {
        let mut cmd = Command::new("moon");
        cmd.arg("check")
            .arg("--warn-list")
            .arg("-28") // avoid warning noise in generated bindings
            .current_dir(&verify.bindings_dir);

        runner.run_command(&mut cmd)?;
        let mut cmd = Command::new("moon");
        cmd.arg("build").current_dir(&verify.bindings_dir);

        runner.run_command(&mut cmd)?;
        Ok(())
    }
}