Migrate resources test to wit-bindgen test (#1266)

I've started mimicking the pattern of some of the more complicated
resource tests where I copy the exact test files as before and configure
the test to not need any modifications there. Not exactly the easiest
way to write the test and probably testing too much but it least makes
these diffs smaller and/or easier to make.

Author: alexcrichton

crates/test-rust-wasm/Cargo.toml

@@ -18,7 +18,3 @@ test = false
 [[bin]]
 name = "options"
 test = false
-
-[[bin]]
-name = "resources"
-test = false

crates/test-rust-wasm/src/bin/resources.rs

@@ -0,0 +1,14 @@
+package example:composition;
+
+let leaf = new test:leaf { ... };
+let resources = new test:resources {
+  imports: leaf.imports,
+  ...
+};
+let runner = new test:runner {
+  exports: resources.exports,
+  ...
+};
+
+export runner...;
+

tests/runtime-new/resources/compose.wac

@@ -0,0 +1,32 @@
+include!(env!("BINDINGS"));
+
+use crate::exports::imports::{Guest, GuestY, Y};
+use std::cell::Cell;
+
+struct Component;
+
+export!(Component);
+
+struct MyY(Cell<i32>);
+
+impl Guest for Component {
+    type Y = MyY;
+}
+
+impl GuestY for MyY {
+    fn new(a: i32) -> MyY {
+        MyY(Cell::new(a))
+    }
+
+    fn get_a(&self) -> i32 {
+        self.0.get()
+    }
+
+    fn set_a(&self, a: i32) {
+        self.0.set(a);
+    }
+
+    fn add(y: Y, a: i32) -> Y {
+        Y::new(MyY::new(y.get::<MyY>().0.get() + a))
+    }
+}

tests/runtime-new/resources/leaf.rs

@@ -1,10 +1,7 @@
-use std::cell::RefCell;
-
-wit_bindgen::generate!({
-    path: "../../tests/runtime/resources",
-});
+include!(env!("BINDINGS"));
 
 use exports::exports::{KebabCase, ZBorrow, X, Z};
+use std::cell::RefCell;
 
 pub struct Test {}
 

tests/runtime/resources/wasm.c renamed to tests/runtime-new/resources/resources.c

@@ -0,0 +1,34 @@
+include!(env!("BINDINGS"));
+
+use crate::exports::*;
+
+fn main() {
+    test_imports().unwrap();
+
+    let x = X::new(5);
+    assert_eq!(x.get_a(), 5);
+    x.set_a(10);
+    assert_eq!(x.get_a(), 10);
+    let z1 = Z::new(10);
+    assert_eq!(z1.get_a(), 10);
+    let z2 = Z::new(20);
+    assert_eq!(z2.get_a(), 20);
+
+    let xadd = X::add(x, 5);
+    assert_eq!(xadd.get_a(), 15);
+
+    let zadd = add(&z1, &z2);
+    assert_eq!(zadd.get_a(), 30);
+
+    let dropped_zs_start = Z::num_dropped();
+
+    drop(z1);
+    drop(z2);
+
+    consume(xadd);
+
+    let dropped_zs_end = Z::num_dropped();
+    if dropped_zs_start != 0 {
+        assert_eq!(dropped_zs_end, dropped_zs_start + 2);
+    }
+}

tests/runtime/resources/wasm.cs renamed to tests/runtime-new/resources/resources.cs

@@ -0,0 +1,84 @@
+//@ dependencies = ['resources', 'leaf']
+//@ wac = 'compose.wac'
+
+package test:resources;
+
+world leaf {
+  export imports: interface {
+    resource y {
+      constructor(a: s32);
+      get-a: func() -> s32;
+      set-a: func(a: s32);
+      add: static func(y: y, a: s32) -> y;
+    }
+  }
+}
+
+world resources {
+  import imports: interface {
+    resource y {
+      constructor(a: s32);
+      get-a: func() -> s32;
+      set-a: func(a: s32);
+      add: static func(y: y, a: s32) -> y;
+    }
+  }
+
+  export exports: interface {
+    resource x {
+      constructor(a: s32);
+      get-a: func() -> s32;
+      set-a: func(a: s32);
+      add: static func(x: x, a: s32) -> x;
+    }
+
+    resource z {
+      constructor(a: s32);
+      get-a: func() -> s32;
+
+      num-dropped: static func() -> u32;
+    }
+
+    add: func(a: borrow<z>, b: borrow<z>) -> own<z>;
+
+    consume: func(x: x);
+
+    resource kebab-case {
+      constructor(a: u32);
+      get-a: func() -> u32;
+      take-owned: static func(k: own<kebab-case>) -> u32;
+    }
+
+    test-imports: func() -> result<_, string>;
+  }
+}
+
+world runner {
+  import exports: interface {
+    resource x {
+      constructor(a: s32);
+      get-a: func() -> s32;
+      set-a: func(a: s32);
+      add: static func(x: x, a: s32) -> x;
+    }
+
+    resource z {
+      constructor(a: s32);
+      get-a: func() -> s32;
+
+      num-dropped: static func() -> u32;
+    }
+
+    add: func(a: borrow<z>, b: borrow<z>) -> own<z>;
+
+    consume: func(x: x);
+
+    resource kebab-case {
+      constructor(a: u32);
+      get-a: func() -> u32;
+      take-owned: static func(k: own<kebab-case>) -> u32;
+    }
+
+    test-imports: func() -> result<_, string>;
+  }
+}

tests/runtime/resources/wasm.rs renamed to tests/runtime-new/resources/resources.rs

@@ -14,7 +14,6 @@ use wit_component::{ComponentEncoder, StringEncoding};
 use wit_parser::{Resolve, WorldId, WorldItem};
 
 mod options;
-mod resources;
 mod results;
 
 struct MyCtx {}