Update wasm-tools crates (#1005)

* Update wasm-tools crates

* Remove usage of multi-return

* Fix C tests

* Mostly update Go tests

Cargo.toml

@@ -32,11 +32,11 @@ indexmap = "2.0.0"
 prettyplease = "0.2.20"
 syn = { version = "2.0", features = ["printing"] }
 
-wasmparser = "0.213.0"
-wasm-encoder = "0.213.0"
-wasm-metadata = "0.213.0"
-wit-parser = "0.213.0"
-wit-component = "0.213.0"
+wasmparser = "0.214.0"
+wasm-encoder = "0.214.0"
+wasm-metadata = "0.214.0"
+wit-parser = "0.214.0"
+wit-component = "0.214.0"
 
 wit-bindgen-core = { path = 'crates/core', version = '0.27.0' }
 wit-bindgen-c = { path = 'crates/c', version = '0.27.0' }

tests/runtime/flavorful/wasm.c

@@ -77,16 +77,15 @@ void flavorful_test_imports() {
     test_flavorful_test_list_typedef3_t b;
     b.ptr = &b_str;
     b.len = 1;
-    test_flavorful_test_list_typedef2_t c;
-    test_flavorful_test_list_typedef3_t d;
-    test_flavorful_test_list_typedefs(&a, &b, &c, &d);
+    flavorful_tuple2_list_typedef2_list_typedef3_t ret;
+    test_flavorful_test_list_typedefs(&a, &b, &ret);
 
-    assert(memcmp(c.ptr, "typedef3", c.len) == 0);
-    assert(d.len == 1);
-    assert(memcmp(d.ptr[0].ptr, "typedef4", d.ptr[0].len) == 0);
+    assert(memcmp(ret.f0.ptr, "typedef3", ret.f0.len) == 0);
+    assert(ret.f1.len == 1);
+    assert(memcmp(ret.f1.ptr[0].ptr, "typedef4", ret.f1.ptr[0].len) == 0);
 
-    test_flavorful_test_list_typedef2_free(&c);
-    test_flavorful_test_list_typedef3_free(&d);
+    test_flavorful_test_list_typedef2_free(&ret.f0);
+    test_flavorful_test_list_typedef3_free(&ret.f1);
   }
 
   {
@@ -109,26 +108,24 @@ void flavorful_test_imports() {
     c.ptr = c_val;
     c.len = 2;
 
-    flavorful_list_bool_t d;
-    test_flavorful_test_list_result_void_void_t e;
-    test_flavorful_test_list_my_errno_t f;
-    test_flavorful_test_list_of_variants(&a, &b, &c, &d, &e, &f);
+    test_flavorful_test_tuple3_list_bool_list_result_void_void_list_my_errno_t ret;
+    test_flavorful_test_list_of_variants(&a, &b, &c, &ret);
 
-    assert(d.len == 2);
-    assert(d.ptr[0] == false);
-    assert(d.ptr[1] == true);
+    assert(ret.f0.len == 2);
+    assert(ret.f0.ptr[0] == false);
+    assert(ret.f0.ptr[1] == true);
 
-    assert(e.len == 2);
-    assert(e.ptr[0].is_err == true);
-    assert(e.ptr[1].is_err == false);
+    assert(ret.f1.len == 2);
+    assert(ret.f1.ptr[0].is_err == true);
+    assert(ret.f1.ptr[1].is_err == false);
 
-    assert(f.len == 2);
-    assert(f.ptr[0] == TEST_FLAVORFUL_TEST_MY_ERRNO_A);
-    assert(f.ptr[1] == TEST_FLAVORFUL_TEST_MY_ERRNO_B);
+    assert(ret.f2.len == 2);
+    assert(ret.f2.ptr[0] == TEST_FLAVORFUL_TEST_MY_ERRNO_A);
+    assert(ret.f2.ptr[1] == TEST_FLAVORFUL_TEST_MY_ERRNO_B);
 
-    flavorful_list_bool_free(&d);
-    test_flavorful_test_list_result_void_void_free(&e);
-    test_flavorful_test_list_my_errno_free(&f);
+    flavorful_list_bool_free(&ret.f0);
+    test_flavorful_test_list_result_void_void_free(&ret.f1);
+    test_flavorful_test_list_my_errno_free(&ret.f2);
   }
 }
 
@@ -181,29 +178,30 @@ bool exports_test_flavorful_test_errno_result(test_flavorful_test_my_errno_t *er
   return false;
 }
 
-void exports_test_flavorful_test_list_typedefs(exports_test_flavorful_test_list_typedef_t *a, exports_test_flavorful_test_list_typedef3_t *c, exports_test_flavorful_test_list_typedef2_t *ret0, exports_test_flavorful_test_list_typedef3_t *ret1) {
+void exports_test_flavorful_test_list_typedefs(
+    exports_test_flavorful_test_list_typedef_t *a,
+    exports_test_flavorful_test_list_typedef3_t *c,
+    flavorful_tuple2_list_typedef2_list_typedef3_t *ret) {
   assert(memcmp(a->ptr, "typedef1", a->len) == 0);
   test_flavorful_test_list_typedef_free(a);
 
   assert(c->len == 1);
   assert(memcmp(c->ptr[0].ptr, "typedef2", c->ptr[0].len) == 0);
   exports_test_flavorful_test_list_typedef3_free(c);
 
-  ret0->ptr = (uint8_t *) malloc(8);
-  ret0->len = 8;
-  memcpy(ret0->ptr, "typedef3", 8);
+  ret->f0.ptr = (uint8_t *) malloc(8);
+  ret->f0.len = 8;
+  memcpy(ret->f0.ptr, "typedef3", 8);
 
-  ret1->ptr = (flavorful_string_t *) malloc(sizeof(flavorful_string_t));
-  ret1->len = 1;
-  flavorful_string_dup(&ret1->ptr[0], "typedef4");
+  ret->f1.ptr = (flavorful_string_t *) malloc(sizeof(flavorful_string_t));
+  ret->f1.len = 1;
+  flavorful_string_dup(&ret->f1.ptr[0], "typedef4");
 }
 
 void exports_test_flavorful_test_list_of_variants(
     flavorful_list_bool_t *a,
     exports_test_flavorful_test_list_result_void_void_t *b,
     exports_test_flavorful_test_list_my_errno_t *c,
-    flavorful_list_bool_t *ret0,
-    exports_test_flavorful_test_list_result_void_void_t *ret1,
-    exports_test_flavorful_test_list_my_errno_t *ret2) {
+    exports_test_flavorful_test_tuple3_list_bool_list_result_void_void_list_my_errno_t *ret) {
   assert(0); // unimplemented
 }

tests/runtime/flavorful/world.wit

@@ -28,10 +28,10 @@ interface test {
   type list-typedef = string;
   type list-typedef2 = list<u8>;
   type list-typedef3 = list<string>;
-  list-typedefs: func(a: list-typedef, c: list-typedef3) -> (a: list-typedef2, b: list-typedef3);
+  list-typedefs: func(a: list-typedef, c: list-typedef3) -> tuple<list-typedef2, list-typedef3>;
 
   list-of-variants: func(a: list<bool>, b: list<result>, c: list<my-errno>)
-    -> (a: list<bool>, b: list<result>, c: list<my-errno>);
+    -> tuple<list<bool>, list<result>, list<my-errno>>;
 }
 
 world flavorful {