Update traits generated for Rust exports (#651)

* Update traits generated for Rust exports

This commit updates the traits generated for Rust exports to be
uniformly named `Guest` as opposed to their previous names which were
based on the name of the interface or world. This reduces some
repetition (e.g. no `foo::Foo`) and additionally enables a nicer fix to
the problem of:

    interface foo {
        record foo {
            foo: u32,
        }
    }

where previously the `struct Foo` generated would clash with `trait
Foo`. Now all types named "guest" are renamed to "Guest_" in Rust and
the `Guest` name is reserved for the generated trait.

This additionally renames resource-related traits to `GuestFoo` in a
similar manner to Wasmtime's bindgen using `HostFoo`.

Also along the lines of namespacing I've renamed `Rep{Foo}` for
resources to just `{Foo}` since the name is now available with the
traits being named `Guest{Foo}`.

This PR still has conflicts where if you have for example:

    interface foo {
        resource foo {
        }

        type guest-foo = u32
    }

that generates an error, but that's getting more niche that I'd prefer
to fix that some other time. (Wasmtime's host bindgen has these same
issues as well)

Closes #650

* Ignore a broken test for java

Author: alexcrichton

crates/rust-lib/src/lib.rs

@@ -436,17 +436,16 @@ pub trait RustGenerator<'a> {
                     }
                 }
                 if self.is_exported_resource(*ty) {
-                    self.push_str(&self.type_path_with_name(
-                        *ty,
-                        format!(
-                        "Rep{}",
-                        self.resolve().types[*ty]
-                            .name
-                            .as_deref()
-                            .unwrap()
-                            .to_upper_camel_case()
-                    ),
-                    ));
+                    self.push_str(
+                        &self.type_path_with_name(
+                            *ty,
+                            self.resolve().types[*ty]
+                                .name
+                                .as_deref()
+                                .unwrap()
+                                .to_upper_camel_case(),
+                        ),
+                    );
                 } else {
                     self.print_ty(&Type::Id(*ty), mode);
                 }
@@ -568,7 +567,7 @@ pub trait RustGenerator<'a> {
             Type::Id(id) => {
                 let ty = &self.resolve().types[*id];
                 match &ty.name {
-                    Some(name) => out.push_str(&name.to_upper_camel_case()),
+                    Some(name) => out.push_str(&to_upper_camel_case(name)),
                     None => match &ty.kind {
                         TypeDefKind::Option(ty) => {
                             out.push_str("Optional");
@@ -836,8 +835,6 @@ pub trait RustGenerator<'a> {
         let info = self.info(id);
 
         for (name, mode) in self.modes_of(id) {
-            let name = name.to_upper_camel_case();
-
             self.rustdoc(docs);
             let lt = self.lifetime_for(&info, mode);
             if let Some(derive_component) = derive_component {
@@ -995,15 +992,15 @@ pub trait RustGenerator<'a> {
     {
         let info = self.info(id);
 
-        let name = name.to_upper_camel_case();
+        let name = to_upper_camel_case(name);
         self.rustdoc(docs);
         for attr in attrs {
             self.push_str(&format!("{}\n", attr));
         }
         self.push_str("#[repr(");
         self.int_repr(enum_.tag());
         self.push_str(")]\n#[derive(Clone, Copy, PartialEq, Eq)]\n");
-        self.push_str(&format!("pub enum {} {{\n", name.to_upper_camel_case()));
+        self.push_str(&format!("pub enum {name} {{\n"));
         for case in enum_.cases.iter() {
             self.rustdoc(&case.docs);
             self.push_str(&case_attr(case));
@@ -1101,7 +1098,7 @@ pub trait RustGenerator<'a> {
             // if only borrows are used, no need to generate the `Own{name}`
             // version.
             self.mark_resource_owned(target);
-            for prefix in ["Own", "Rep"] {
+            for prefix in ["Own", ""] {
                 self.rustdoc(docs);
                 self.push_str(&format!(
                     "pub type {prefix}{} = {};\n",
@@ -1148,11 +1145,7 @@ pub trait RustGenerator<'a> {
 
     fn param_name(&self, ty: TypeId) -> String {
         let info = self.info(ty);
-        let name = self.resolve().types[ty]
-            .name
-            .as_ref()
-            .unwrap()
-            .to_upper_camel_case();
+        let name = to_upper_camel_case(self.resolve().types[ty].name.as_ref().unwrap());
         if self.uses_two_names(&info) {
             format!("{}Param", name)
         } else {
@@ -1162,11 +1155,7 @@ pub trait RustGenerator<'a> {
 
     fn result_name(&self, ty: TypeId) -> String {
         let info = self.info(ty);
-        let name = self.resolve().types[ty]
-            .name
-            .as_ref()
-            .unwrap()
-            .to_upper_camel_case();
+        let name = to_upper_camel_case(self.resolve().types[ty].name.as_ref().unwrap());
         if self.uses_two_names(&info) {
             format!("{}Result", name)
         } else if self.is_exported_resource(ty) {
@@ -1398,6 +1387,15 @@ pub fn to_rust_ident(name: &str) -> String {
     }
 }
 
+pub fn to_upper_camel_case(name: &str) -> String {
+    match name {
+        // The name "Guest" is reserved for traits generated by exported
+        // interfaces, so remap types defined in wit to something else.
+        "guest" => "Guest_".to_string(),
+        s => s.to_upper_camel_case(),
+    }
+}
+
 pub fn wasm_type(ty: WasmType) -> &'static str {
     match ty {
         WasmType::I32 => "i32",