merge: wit-bindgen 0.50

Merge upstream wit-bindgen 0.50.0 into the vendored bindgen subtree.

- Bump wit-bindgen-core 0.49 -> 0.50 (wit-parser stays 0.243); no API churn.

Non-carries (not applicable to wRPC, dropped from the merge):
- the rebooted Go generator (bytecodealliance/wit-bindgen#1447, a brand-new `crates/go/` of ~4k lines plus
  Go runtime sources). Upstream removed its original Go backend at 0.41 and
  rewrote a completely different one here; wRPC's `wit-bindgen-go` is the
  pre-removal fork and continues independently, so the rebooted `crates/go` is
  dropped (and added to the merge DROP filter going forward). All subsequent
  Go-only upstream changes likewise do not apply.
- bytecodealliance/wit-bindgen#1442 (custom Rust types for `list`) is implemented in the canonical-ABI
  `bindgen.rs`; wRPC already supports remapping named `list` type aliases through
  its per-type `with` remapping (bytecodealliance/wit-bindgen#1173, exercised by the `aliased_lists` test).
- bytecodealliance/wit-bindgen#1444 (`build.rs` binding-generation helpers) changes `Opts::build()` to return
  a concrete generator, which is incompatible with wRPC's CLI dispatching Rust
  and Go generators polymorphically via `Box<dyn WorldGenerator>`; wRPC's primary
  path is the `generate!` macro.

rust codegen (243) and go codegen (81) tests pass; `cargo clippy --workspace`
and `cargo doc --workspace` are clean; wasmtime and all examples build.

Assisted-by: claude:claude-opus-4-8
Upstream diff: bytecodealliance/wit-bindgen@v0.49.0...v0.50.0

Author: rvolosatovs

Cargo.lock

@@ -179,7 +179,7 @@ wasmtime-cli-flags = { version = "45", default-features = false }
 wasmtime-wasi = { version = "45", default-features = false }
 wasmtime-wasi-http = { version = "45", default-features = false }
 wit-bindgen = { version = "0.45", default-features = false }
-wit-bindgen-core = { version = "0.49", default-features = false }
+wit-bindgen-core = { version = "0.50", default-features = false }
 wit-bindgen-wrpc = { version = "0.11", default-features = false, path = "./crates/wit-bindgen" }
 wit-bindgen-wrpc-go = { version = "0.13", default-features = false, path = "./crates/wit-bindgen-go" }
 wit-bindgen-wrpc-rust = { version = "0.11", default-features = false, path = "./crates/wit-bindgen-rust" }

Cargo.toml

@@ -0,0 +1,146 @@
+use crate::{Compile, LanguageMethods, Runner, Verify};
+use anyhow::{Context as _, Result};
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+pub struct Go;
+
+impl LanguageMethods for Go {
+    fn display(&self) -> &str {
+        "go"
+    }
+
+    fn comment_prefix_for_test_config(&self) -> Option<&str> {
+        Some("//@")
+    }
+
+    fn should_fail_verify(
+        &self,
+        name: &str,
+        config: &crate::config::WitConfig,
+        _args: &[String],
+    ) -> bool {
+        // TODO: We _do_ support async, but only with a build of Go that has
+        // [this
+        // patch](https://github.com/dicej/go/commit/40fc123d5bce6448fc4e4601fd33bad4250b36a5).
+        // Once we upstream something equivalent, we can remove the ` || name ==
+        // "async-trait-function.wit"` here.
+        config.error_context || name == "async-trait-function.wit"
+    }
+
+    fn default_bindgen_args_for_codegen(&self) -> &[&str] {
+        &["--generate-stubs"]
+    }
+
+    fn prepare(&self, runner: &mut Runner<'_>) -> Result<()> {
+        let cwd = env::current_dir()?;
+        let dir = cwd.join(&runner.opts.artifacts).join("go");
+
+        super::write_if_different(&dir.join("test.go"), "package main\n\nfunc main() {}")?;
+        super::write_if_different(&dir.join("go.mod"), "module test\n\ngo 1.25")?;
+
+        println!("Testing if `go build` works...");
+        runner.run_command(
+            Command::new("go")
+                .current_dir(&dir)
+                .env("GOOS", "wasip1")
+                .env("GOARCH", "wasm")
+                .arg("build")
+                .arg("-buildmode=c-shared")
+                .arg("-ldflags=-checklinkname=0"),
+        )
+    }
+
+    fn compile(&self, runner: &Runner<'_>, compile: &Compile<'_>) -> Result<()> {
+        let output = compile.output.with_extension("core.wasm");
+
+        // Tests which involve importing and/or exporting more than one
+        // interface may require more than one file since we can't define more
+        // than one package in a single file in Go (AFAICT).  Here we search for
+        // files related to `compile.component.path` based on a made-up naming
+        // convention.  For example, if the filename is `test.go`, then we'll
+        // also include `${prefix}+test.go` for any value of `${prefix}`.
+        for path in all_paths(&compile.component.path)? {
+            let test = fs::read_to_string(&path)
+                .with_context(|| format!("unable to read `{}`", path.display()))?;
+            let package_name = package_name(&test);
+            let package_dir = compile.bindings_dir.join(package_name);
+            fs::create_dir_all(&package_dir)
+                .with_context(|| format!("unable to create `{}`", package_dir.display()))?;
+            let output = &package_dir.join(path.file_name().unwrap());
+            fs::write(output, test.as_bytes())
+                .with_context(|| format!("unable to write `{}`", output.display()))?;
+        }
+
+        runner.run_command(
+            Command::new("go")
+                .current_dir(&compile.bindings_dir)
+                .env("GOOS", "wasip1")
+                .env("GOARCH", "wasm")
+                .arg("build")
+                .arg("-o")
+                .arg(&output)
+                .arg("-buildmode=c-shared")
+                .arg("-ldflags=-checklinkname=0"),
+        )?;
+
+        runner.convert_p1_to_component(&output, compile)?;
+
+        Ok(())
+    }
+
+    fn verify(&self, runner: &Runner<'_>, verify: &Verify<'_>) -> Result<()> {
+        runner.run_command(
+            Command::new("go")
+                .current_dir(&verify.bindings_dir)
+                .env("GOOS", "wasip1")
+                .env("GOARCH", "wasm")
+                .arg("build")
+                .arg("-o")
+                .arg(verify.artifacts_dir.join("tmp.wasm"))
+                .arg("-buildmode=c-shared")
+                .arg("-ldflags=-checklinkname=0"),
+        )
+    }
+}
+
+fn package_name(package: &str) -> &str {
+    package
+        .split_once('\n')
+        .unwrap()
+        .0
+        .strip_prefix("package ")
+        .unwrap()
+        .trim()
+}
+
+fn all_paths(path: &Path) -> Result<Vec<PathBuf>> {
+    let mut paths = vec![path.into()];
+    let suffix = ".go";
+    if let Some(name) = path
+        .file_name()
+        .unwrap()
+        .to_str()
+        .and_then(|name| name.strip_suffix(suffix))
+    {
+        let suffix = &format!("+{name}{suffix}");
+        let parent = path.parent().unwrap();
+        for entry in parent
+            .read_dir()
+            .with_context(|| format!("unable to read dir `{}`", parent.display()))?
+        {
+            let entry = entry?;
+            if entry
+                .file_name()
+                .to_str()
+                .and_then(|name| name.strip_suffix(suffix))
+                .is_some()
+            {
+                paths.push(entry.path());
+            }
+        }
+    }
+    Ok(paths)
+}