The implements clause lets a world import or export the same interface

multiple times under different plain names:

    world runner {
      import primary: store;
      import backup:  store;
    }

No bindings-generator changes needed. wit-parser surfaces each label as
a plain-name interface import/export, `generate_nominal_type_ids` gives each
its own type identity, and the existing plain-name interface code path emits
label-named modules and `wasm_import_module`s.

The test covers Rust, Go, and WAT runners with Rust and Go tests, composed
via `compose.wac` so the two labels resolve to two independent `store`
instances.

Temporary, until releases catch up:
- `wac` is pointed at the `implements` branch; composition support for the
  clause is not yet in a released wac.
- CI's wasmtime is pinned to the `dev` build; the clause has landed on
  wasmtime `main` but is not yet released.

Signed-off-by: Bailey Hayes <bailey@cosmonic.com>

Author: ricochet

.github/actions/install-wasi-sdk/action.yml

@@ -38,4 +38,8 @@ runs:
     - name: Setup `wasmtime`
       uses: bytecodealliance/actions/wasmtime/setup@v1
       with:
-        version: "44.0.0"
+        # Pinned to the rolling `dev` build (main, which will become wasmtime
+        # 47) because the component model `implements` clause used by the
+        # `implements` runtime test has landed on `main` but is not in a
+        # released wasmtime yet.
+        version: "dev"

Cargo.lock

@@ -120,3 +120,11 @@ csharp = ['dep:wit-bindgen-csharp']
 csharp-mono = ['csharp']
 moonbit = ['dep:wit-bindgen-moonbit']
 async = []
+
+# The component model `implements` clause requires composition support that is
+# not yet in a released `wac`. Until that ships on crates.io, point the `wac`
+# crates at the `implements` branch.
+[patch.crates-io]
+wac-parser = { git = "https://github.com/ricochet/wac", branch = "implements" }
+wac-types = { git = "https://github.com/ricochet/wac", branch = "implements" }
+wac-graph = { git = "https://github.com/ricochet/wac", branch = "implements" }

Cargo.toml

@@ -0,0 +1,16 @@
+package example:composition;
+
+// Instantiate the `test` component twice to back the two labeled imports of the
+// runner. The component model `implements` clause lets the runner import the
+// same `store` interface under two different plain names (`primary` and
+// `backup`), each wired here to its own independent instance.
+let primary = new test:test { ... };
+let backup = new test:test { ... };
+
+let runner = new test:runner {
+  primary: primary.store,
+  backup: backup.store,
+  ...
+};
+
+export runner...;

tests/runtime/implements/compose.wac

@@ -0,0 +1,33 @@
+package export_wit_world
+
+import (
+	"wit_component/backup"
+	"wit_component/primary"
+
+	. "go.bytecodealliance.org/pkg/wit/types"
+)
+
+func Run() {
+	// Each labeled import is its own instance of `store`, so values set
+	// through `primary` are independent from those set through `backup`.
+	primary.Set("key", "from-primary")
+	backup.Set("key", "from-backup")
+
+	assertSome(primary.Get("key"), "from-primary")
+	assertSome(backup.Get("key"), "from-backup")
+
+	assertNone(primary.Get("missing"))
+	assertNone(backup.Get("missing"))
+}
+
+func assertSome(opt Option[string], expected string) {
+	if opt.Tag() != OptionSome || opt.Some() != expected {
+		panic("unexpected value")
+	}
+}
+
+func assertNone(opt Option[string]) {
+	if opt.Tag() != OptionNone {
+		panic("expected none")
+	}
+}

tests/runtime/implements/runner.go

@@ -0,0 +1,20 @@
+include!(env!("BINDINGS"));
+
+struct Component;
+
+export!(Component);
+
+impl Guest for Component {
+    fn run() {
+        // Each labeled import is its own instance of `store`, so values set
+        // through `primary` are independent from those set through `backup`.
+        primary::set("key", "from-primary");
+        backup::set("key", "from-backup");
+
+        assert_eq!(primary::get("key").as_deref(), Some("from-primary"));
+        assert_eq!(backup::get("key").as_deref(), Some("from-backup"));
+
+        assert_eq!(primary::get("missing"), None);
+        assert_eq!(backup::get("missing"), None);
+    }
+}

tests/runtime/implements/runner.rs

@@ -0,0 +1,20 @@
+;; A `runner` written directly in WebAssembly text. It imports the same `store`
+;; interface twice under two different plain names (`primary` and `backup`) via
+;; the component model `implements` clause, so the two imports appear as distinct
+;; core wasm import modules.
+(module
+  (import "primary" "set" (func $primary-set (param i32 i32 i32 i32)))
+  (import "backup" "set" (func $backup-set (param i32 i32 i32 i32)))
+
+  (memory (export "memory") 1)
+
+  ;; "key" @ 0 (len 3), "primary" @ 3 (len 7), "backup" @ 10 (len 6)
+  (data (i32.const 0) "keyprimarybackup")
+
+  (func (export "run")
+    ;; primary::set("key", "primary")
+    (call $primary-set (i32.const 0) (i32.const 3) (i32.const 3) (i32.const 7))
+    ;; backup::set("key", "backup")
+    (call $backup-set (i32.const 0) (i32.const 3) (i32.const 10) (i32.const 6))
+  )
+)

tests/runtime/implements/runner.wat

@@ -0,0 +1,18 @@
+package export_test_implements_store
+
+import (
+	. "go.bytecodealliance.org/pkg/wit/types"
+)
+
+var store = map[string]string{}
+
+func Get(key string) Option[string] {
+	if value, ok := store[key]; ok {
+		return Some[string](value)
+	}
+	return None[string]()
+}
+
+func Set(key string, value string) {
+	store[key] = value
+}