Migrate all tests to using world-file-syntax (#432)

* Update all codegen tests to world syntax

This enables simplifying codegen tests as well by having each test
exercise imports/exports instead of having all code generators have one
case for imports and one for exports.

* Update codegen tests for the C guest generator

* Update teavm codegen tests for worlds

* Remove the `--name` argument from the CLI

No longer needed as the name is inferred from the `*.wit` world.

* Get all js host generator tests working

Update all `runtime/*` tests with new naming conventions, world files,
etc. Minor updates were made to names as I ended up using different
conventions for the `*.wit` world files than were previously exercised.

This also fixes a few minor issues with the output for the JS generator
in the default ESM mode.

* Get all host-wasmtime tests working with worlds

Various small updates here and there to namings and such.

* Get all Python tests working with worlds

Fix support for exported instances by using correct import paths for
various types/intrinsics/etc. Additionally update the codegen tests to
specify a mypy cache dir to avoid racing between tests.

* Update demo build for worlds

Also fix an issue with the Rust host generator where it used an
interface's name instead of the name of the import for import module names.

* Update demo with world files

Author: alexcrichton

crates/gen-guest-c/src/lib.rs

@@ -72,7 +72,7 @@ impl WorldGenerator for C {
     }
 
     fn import(&mut self, name: &str, iface: &Interface, _files: &mut Files) {
-        let mut gen = self.interface(iface, true);
+        let mut gen = self.interface(name, iface, true);
         gen.types();
 
         for (i, func) in iface.functions.iter().enumerate() {
@@ -88,7 +88,7 @@ impl WorldGenerator for C {
     }
 
     fn export(&mut self, name: &str, iface: &Interface, _files: &mut Files) {
-        let mut gen = self.interface(iface, false);
+        let mut gen = self.interface(name, iface, false);
         gen.types();
 
         for (i, func) in iface.functions.iter().enumerate() {
@@ -104,7 +104,7 @@ impl WorldGenerator for C {
     }
 
     fn export_default(&mut self, name: &str, iface: &Interface, _files: &mut Files) {
-        let mut gen = self.interface(iface, false);
+        let mut gen = self.interface(name, iface, false);
         gen.types();
 
         for (i, func) in iface.functions.iter().enumerate() {
@@ -294,12 +294,14 @@ impl WorldGenerator for C {
 impl C {
     fn interface<'a>(
         &'a mut self,
+        name: &'a str,
         iface: &'a Interface,
         in_import: bool,
     ) -> InterfaceGenerator<'a> {
         let mut sizes = SizeAlign::default();
         sizes.fill(iface);
         InterfaceGenerator {
+            name,
             src: Source::default(),
             gen: self,
             iface,
@@ -325,6 +327,7 @@ impl C {
 }
 
 struct InterfaceGenerator<'a> {
+    name: &'a str,
     src: Source,
     in_import: bool,
     gen: &'a mut C,
@@ -483,7 +486,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
             uwriteln!(
                 self.src.h_defs,
                 "#define {}_{}_{} (1 << {})",
-                self.iface.name.to_shouty_snake_case(),
+                self.name.to_shouty_snake_case(),
                 name.to_shouty_snake_case(),
                 flag.name.to_shouty_snake_case(),
                 i,
@@ -520,7 +523,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
             uwriteln!(
                 self.src.h_defs,
                 "#define {}_{}_{} {}",
-                self.iface.name.to_shouty_snake_case(),
+                self.name.to_shouty_snake_case(),
                 name.to_shouty_snake_case(),
                 case.name.to_shouty_snake_case(),
                 i,
@@ -603,7 +606,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
             uwriteln!(
                 self.src.h_defs,
                 "#define {}_{}_{} {}",
-                self.iface.name.to_shouty_snake_case(),
+                self.name.to_shouty_snake_case(),
                 name.to_shouty_snake_case(),
                 case.name.to_shouty_snake_case(),
                 i,
@@ -655,12 +658,12 @@ impl InterfaceGenerator<'_> {
         uwriteln!(
             self.src.h_fns,
             "__attribute__((import_module(\"{}\"), import_name(\"{}\")))",
-            self.iface.name,
+            self.name,
             func.name
         );
         let import_name = self.gen.names.tmp(&format!(
             "__wasm_import_{}_{}",
-            self.iface.name.to_snake_case(),
+            self.name.to_snake_case(),
             func.name.to_snake_case()
         ));
         match sig.results.len() {
@@ -732,7 +735,7 @@ impl InterfaceGenerator<'_> {
         );
         let import_name = self.gen.names.tmp(&format!(
             "__wasm_export_{}_{}",
-            self.iface.name.to_snake_case(),
+            self.name.to_snake_case(),
             func.name.to_snake_case()
         ));
 
@@ -851,7 +854,7 @@ impl InterfaceGenerator<'_> {
     fn print_sig(&mut self, func: &Function) -> CSig {
         let name = format!(
             "{}_{}",
-            self.iface.name.to_snake_case(),
+            self.name.to_snake_case(),
             func.name.to_snake_case()
         );
         self.gen.names.insert(&name).expect("duplicate symbols");
@@ -958,7 +961,7 @@ impl InterfaceGenerator<'_> {
     }
 
     fn print_typedef_target(&mut self, name: &str) {
-        let iface_snake = self.iface.name.to_snake_case();
+        let iface_snake = self.name.to_snake_case();
         let snake = name.to_snake_case();
         self.print_namespace(SourceType::HDefs);
         self.src.h_defs(&snake);
@@ -970,7 +973,7 @@ impl InterfaceGenerator<'_> {
     }
 
     fn print_namespace(&mut self, stype: SourceType) {
-        self.src.print(stype, &self.iface.name.to_snake_case());
+        self.src.print(stype, &self.name.to_snake_case());
         self.src.print(stype, "_");
     }
 
@@ -2070,7 +2073,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 self.src.push_str(");\n");
             }
 
-            Instruction::CallInterface { module: _, func } => {
+            Instruction::CallInterface { func } => {
                 let mut args = String::new();
                 for (i, (op, (byref, _))) in operands.iter().zip(&self.sig.params).enumerate() {
                     if i > 0 {

crates/gen-guest-c/tests/codegen.rs

@@ -3,38 +3,25 @@ use std::env;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-macro_rules! gen_test {
-    ($name:ident $test:tt $dir:ident) => {
+macro_rules! codegen_test {
+    ($name:ident $test:tt) => {
         #[test]
         fn $name() {
             test_helpers::run_world_codegen_test(
                 "guest-c",
                 $test.as_ref(),
-                test_helpers::Direction::$dir,
                 |name, interfaces, files| {
                     wit_bindgen_gen_guest_c::Opts::default()
                         .build()
                         .generate(name, interfaces, files)
                 },
-                super::verify,
+                verify,
             )
         }
     };
 }
 
-mod exports {
-    macro_rules! codegen_test {
-        ($name:ident $test:tt) => (gen_test!($name $test Export);)
-    }
-    test_helpers::codegen_tests!("*.wit");
-}
-
-mod imports {
-    macro_rules! codegen_test {
-        ($name:ident $test:tt) => (gen_test!($name $test Import);)
-    }
-    test_helpers::codegen_tests!("*.wit");
-}
+test_helpers::codegen_tests!("*.wit");
 
 fn verify(dir: &Path, name: &str) {
     let path = PathBuf::from(env::var_os("WASI_SDK_PATH").unwrap());

crates/gen-guest-rust/src/lib.rs

@@ -86,6 +86,7 @@ impl RustWasm {
 
     fn interface<'a>(
         &'a mut self,
+        name: &'a str,
         iface: &'a Interface,
         default_param_mode: TypeMode,
         in_import: bool,
@@ -96,6 +97,7 @@ impl RustWasm {
         types.analyze(iface);
 
         InterfaceGenerator {
+            name,
             src: Source::default(),
             in_import,
             gen: self,
@@ -111,7 +113,7 @@ impl RustWasm {
 
 impl WorldGenerator for RustWasm {
     fn import(&mut self, name: &str, iface: &Interface, _files: &mut Files) {
-        let mut gen = self.interface(iface, TypeMode::AllBorrowed("'a"), true);
+        let mut gen = self.interface(name, iface, TypeMode::AllBorrowed("'a"), true);
         gen.types();
 
         for func in iface.functions.iter() {
@@ -122,12 +124,12 @@ impl WorldGenerator for RustWasm {
     }
 
     fn export(&mut self, name: &str, iface: &Interface, _files: &mut Files) {
-        self.interface(iface, TypeMode::Owned, false)
+        self.interface(name, iface, TypeMode::Owned, false)
             .generate_exports(name, Some(name));
     }
 
     fn export_default(&mut self, name: &str, iface: &Interface, _files: &mut Files) {
-        self.interface(iface, TypeMode::Owned, false)
+        self.interface(name, iface, TypeMode::Owned, false)
             .generate_exports(name, None);
     }
 
@@ -237,6 +239,7 @@ struct InterfaceGenerator<'a> {
     types: Types,
     sizes: SizeAlign,
     gen: &'a mut RustWasm,
+    name: &'a str,
     iface: &'a Interface,
     default_param_mode: TypeMode,
     return_pointer_area_size: usize,
@@ -374,6 +377,7 @@ impl InterfaceGenerator<'_> {
             "
                 #[doc(hidden)]
                 #[export_name = \"{export_name}\"]
+                #[allow(non_snake_case)]
                 unsafe extern \"C\" fn __export_{iface_snake}_{name_snake}(\
             ",
         );
@@ -443,6 +447,7 @@ impl InterfaceGenerator<'_> {
                 "
                     #[doc(hidden)]
                     #[export_name = \"cabi_post_{export_name}\"]
+                    #[allow(non_snake_case)]
                     unsafe extern \"C\" fn __post_return_{iface_snake}_{name_snake}(\
                 "
             );
@@ -662,25 +667,22 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
 
     fn declare_import(
         &mut self,
-        iface: &Interface,
+        module_name: &str,
         name: &str,
         params: &[WasmType],
         results: &[WasmType],
     ) -> String {
         // Define the actual function we're calling inline
-        self.push_str("#[link(wasm_import_module = \"");
-        self.push_str(&iface.name);
-        self.push_str("\")]\n");
-        self.push_str("extern \"C\" {\n");
-        self.push_str("#[cfg_attr(target_arch = \"wasm32\", link_name = \"");
-        self.push_str(name);
-        self.push_str("\")]\n");
-        self.push_str("#[cfg_attr(not(target_arch = \"wasm32\"), link_name = \"");
-        self.push_str(&iface.name);
-        self.push_str("_");
-        self.push_str(name);
-        self.push_str("\")]\n");
-        self.push_str("fn wit_import(");
+        uwriteln!(
+            self.src,
+            "
+                #[link(wasm_import_module = \"{module_name}\")]
+                extern \"C\" {{
+                    #[cfg_attr(target_arch = \"wasm32\", link_name = \"{name}\")]
+                    #[cfg_attr(not(target_arch = \"wasm32\"), link_name = \"{module_name}_{name}\")]
+                    fn wit_import(\
+            "
+        );
         for param in params.iter() {
             self.push_str("_: ");
             self.push_str(wasm_type(*param));
@@ -1312,8 +1314,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
             Instruction::IterBasePointer => results.push("base".to_string()),
 
-            Instruction::CallWasm { iface, name, sig } => {
-                let func = self.declare_import(iface, name, &sig.params, &sig.results);
+            Instruction::CallWasm { name, sig, .. } => {
+                let func = self.declare_import(self.gen.name, name, &sig.params, &sig.results);
 
                 // ... then call the function with all our operands
                 if sig.results.len() > 0 {