Update the guest C generator for world-based generation (#396)

This commit removes the `Generator` trait impl for the C generator and
adds the `WorldGenerator` trait impl to replace it. This is the
equivalent of #386 for the guest C generator.

The generated C code is largely the same, except that the entire world
is represented in one header file instead of per-interface header files
as before. Additionally a tiny amount of "type sharing" is now done
where all interfaces share the same string type (namespaced by the
world name). More type sharing should come with a more first-class
implementation of worlds.

There was quite a lot of code movement within the generator as I got it
working again, but at the surface level very little has changed and it
should largely be the same as before.

Author: alexcrichton

crates/bindgen-core/src/lib.rs

@@ -564,6 +564,7 @@ mod tests {
 
 pub trait WorldGenerator {
     fn generate(&mut self, name: &str, interfaces: &ComponentInterfaces, files: &mut Files) {
+        self.preprocess(name);
         for (name, import) in interfaces.imports.iter() {
             self.import(name, import, files);
         }
@@ -576,6 +577,10 @@ pub trait WorldGenerator {
         self.finish(name, interfaces, files);
     }
 
+    fn preprocess(&mut self, name: &str) {
+        drop(name);
+    }
+
     fn import(&mut self, name: &str, iface: &Interface, files: &mut Files);
     fn export(&mut self, name: &str, iface: &Interface, files: &mut Files);
     fn export_default(&mut self, name: &str, iface: &Interface, files: &mut Files);

crates/gen-guest-c/Cargo.toml

@@ -17,4 +17,4 @@ heck = { workspace = true }
 clap = { workspace = true, optional = true }
 
 [dev-dependencies]
-test-helpers = { path = '../test-helpers', default-features = false }
+test-helpers = { path = '../test-helpers', default-features = false, features = ['macros'] }

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

@@ -3,21 +3,14 @@ use heck::ToSnakeCase;
 use wasm_encoder::{
     CodeSection, CustomSection, Encode, Function, FunctionSection, Module, TypeSection,
 };
-use wit_bindgen_core::{wit_parser::Interface, Direction};
-use wit_component::ComponentEncoder;
+use wit_component::{ComponentEncoder, ComponentInterfaces};
 
-pub fn linking_symbol(iface: &Interface, direction: Direction) -> String {
-    format!(
-        "__component_type_object_force_link_{}_{}",
-        iface.name.to_snake_case(),
-        match direction {
-            Direction::Import => "import",
-            Direction::Export => "export",
-        }
-    )
+pub fn linking_symbol(name: &str) -> String {
+    let snake = name.to_snake_case();
+    format!("__component_type_object_force_link_{snake}")
 }
 
-pub fn object(iface: &Interface, direction: Direction) -> Result<Vec<u8>> {
+pub fn object(name: &str, interfaces: &ComponentInterfaces) -> Result<Vec<u8>> {
     let mut module = Module::new();
 
     // Build a module with one function that's a "dummy function"
@@ -31,32 +24,28 @@ pub fn object(iface: &Interface, direction: Direction) -> Result<Vec<u8>> {
     code.function(&Function::new([]));
     module.section(&code);
 
-    let mut encoder = ComponentEncoder::default();
-    encoder = match direction {
-        Direction::Import => encoder.imports([iface.clone()])?,
-        Direction::Export => encoder.interface(iface.clone())?,
-    };
+    let mut encoder = ComponentEncoder::default()
+        .imports(interfaces.imports.values().cloned())?
+        .exports(interfaces.exports.values().cloned())?;
+
+    if let Some(default) = &interfaces.default {
+        encoder = encoder.interface(default.clone())?;
+    }
+
     let data = encoder
         .types_only(true)
         .encode()
-        .with_context(|| format!("translating interface {} to component type", iface.name))?;
+        .with_context(|| format!("translating {name} to component type"))?;
 
     // The custom section name here must start with "component-type" but
     // otherwise is attempted to be unique here to ensure that this doesn't get
     // concatenated to other custom sections by LLD by accident since LLD will
     // concatenate custom sections of the same name.
-    let name = format!(
-        "component-type:{}:{}",
-        match direction {
-            Direction::Import => "import",
-            Direction::Export => "export",
-        },
-        iface.name
-    );
+    let section_name = format!("component-type:{name}",);
 
     // Add our custom section
     module.section(&CustomSection {
-        name: &name,
+        name: &section_name,
         data: data.as_slice(),
     });
 
@@ -69,7 +58,7 @@ pub fn object(iface: &Interface, direction: Direction) -> Result<Vec<u8>> {
         subsection.push(0x00); // SYMTAB_FUNCTION
         0u32.encode(&mut subsection); // flags
         0u32.encode(&mut subsection); // index
-        linking_symbol(iface, direction).encode(&mut subsection); // name
+        linking_symbol(name).encode(&mut subsection); // name
 
         data.push(0x08); // `WASM_SYMBOL_TABLE`
         subsection.encode(&mut data);