fix(C): Resource name in import should be the original name (#806)

* fix(C): Resource name in import should be the original name

* fix(tinygo): Resource C type name should be snake case

* Add a runtime test for kebab-case resource names

Author: kateinoigakukun

crates/c/src/lib.rs

@@ -1051,7 +1051,7 @@ void {ns}_{snake}_destructor({ty_name} *rep);
 __attribute__(( __import_module__("[export]{module}"), __import_name__("[resource-new]{name}")))
 extern int32_t __wasm_import_{ns}_{snake}_new(int32_t);
 
-__attribute__((__import_module__("[export]{module}"), __import_name__("[resource-rep]{snake}")))
+__attribute__((__import_module__("[export]{module}"), __import_name__("[resource-rep]{name}")))
 extern int32_t __wasm_import_{ns}_{snake}_rep(int32_t);
 
 {own} {ns}_{snake}_new({ty_name} *rep) {{

crates/go/src/bindgen.rs

@@ -342,7 +342,8 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
                                 let snake = self.interface.resolve.types[resource]
                                     .name
                                     .as_ref()
-                                    .unwrap();
+                                    .unwrap()
+                                    .to_snake_case();
                                 // If the resource is exported, then `type_resource` have created a
                                 // internal bookkeeping map for this resource. We will need to
                                 // use the map to get the resource interface. Otherwise, this resource
@@ -371,14 +372,14 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
                                         Own(_) => {
                                             let mut own = ns.clone();
                                             own.push_str("_own_");
-                                            own.push_str(snake);
+                                            own.push_str(&snake);
                                             own.push_str("_t");
                                             own
                                         }
                                         Borrow(_) => {
                                             let mut borrow = ns.clone();
                                             borrow.push_str("_borrow_");
-                                            borrow.push_str(snake);
+                                            borrow.push_str(&snake);
                                             borrow.push_str("_t");
                                             borrow
                                         }
@@ -639,7 +640,8 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
                                 let snake = self.interface.resolve.types[resource]
                                     .name
                                     .as_ref()
-                                    .unwrap();
+                                    .unwrap()
+                                    .to_snake_case();
                                 if self.interface.gen.exported_resources.contains(&resource) {
                                     let resource_name: String =
                                         self.interface.get_ty(&Type::Id(resource)).to_snake_case();

crates/go/src/interface.rs

@@ -1060,10 +1060,14 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
                 // generate a typedef struct for export resource
                 let c_typedef_target = self.gen.c_type_names[&id].clone();
                 let ns = self.c_namespace_of_resource(id);
-                let snake = self.resolve.types[id].name.as_ref().unwrap();
+                let snake = self.resolve.types[id]
+                    .name
+                    .as_ref()
+                    .unwrap()
+                    .to_snake_case();
                 let mut own = ns.clone();
                 own.push_str("_own_");
-                own.push_str(snake);
+                own.push_str(&snake);
                 own.push_str("_t");
 
                 // generate a typedef struct for export resource

tests/runtime/resources/wasm.c

@@ -11,6 +11,10 @@ struct exports_z_t {
     int32_t a;
 };
 
+struct exports_kebab_case_t {
+    int32_t a;
+};
+
 exports_own_x_t exports_constructor_x(int32_t a) {
     exports_x_t* x_instance = (exports_x_t*)malloc(sizeof(exports_x_t));
     x_instance->a = a;
@@ -56,6 +60,23 @@ void exports_z_destructor(exports_z_t* z) {
     free(z);
 }
 
+exports_own_kebab_case_t exports_constructor_kebab_case(uint32_t a) {
+    exports_kebab_case_t* kc_instance = (exports_kebab_case_t*)malloc(sizeof(exports_kebab_case_t));
+    kc_instance->a = a;
+    exports_own_kebab_case_t kc_own = exports_kebab_case_new(kc_instance);
+    return kc_own;
+}
+
+uint32_t exports_method_kebab_case_get_a(exports_borrow_kebab_case_t self) {
+    return self->a;
+}
+
+uint32_t exports_static_kebab_case_take_owned(exports_own_kebab_case_t k) {
+    return exports_kebab_case_rep(k)->a;
+}
+
+void exports_kebab_case_destructor(exports_kebab_case_t *rep) {}
+
 bool exports_test_imports(resources_string_t *err) {
     imports_own_y_t y = imports_constructor_y(10);
     imports_borrow_y_t borrowed_y = imports_borrow_y(y);

tests/runtime/resources/wasm.go

@@ -20,6 +20,10 @@ type MyZ struct {
 	a int32
 }
 
+type MyKebabCase struct {
+	a uint32
+}
+
 func (e ExportsImpl) ConstructorX(a int32) ExportsX {
 	return &MyX{a: a}
 }
@@ -28,6 +32,10 @@ func (e ExportsImpl) ConstructorZ(a int32) ExportsZ {
 	return &MyZ{a: a}
 }
 
+func (e ExportsImpl) ConstructorKebabCase(a uint32) ExportsKebabCase {
+	return &MyKebabCase{a: a}
+}
+
 func (x *MyX) MethodXGetA() int32 {
 	return x.a
 }
@@ -48,6 +56,14 @@ func (e ExportsImpl) Add(z ExportsZ, b ExportsZ) ExportsZ {
 	return &MyZ{a: z.MethodZGetA() + b.MethodZGetA()}
 }
 
+func (k *MyKebabCase) MethodKebabCaseGetA() uint32 {
+	return k.a
+}
+
+func (e ExportsImpl) StaticKebabCaseTakeOwned(k ExportsKebabCase) uint32 {
+	return k.MethodKebabCaseGetA()
+}
+
 func (e ExportsImpl) TestImports() Result[struct{}, string] {
 	y := NewY(1)
 	if y.GetA() != 1 {

tests/runtime/resources/wasm.rs

@@ -7,10 +7,12 @@ wit_bindgen::generate!({
         "exports": Test,
         "exports/x": ComponentX,
         "exports/z": ComponentZ,
+        "exports/kebab-case": ComponentKebabCase,
     }
 });
 
 use exports::exports::OwnX;
+use exports::exports::OwnKebabCase;
 
 pub struct Test {}
 
@@ -22,6 +24,10 @@ pub struct ComponentZ {
     val: i32,
 }
 
+pub struct ComponentKebabCase {
+    val: u32,
+}
+
 impl exports::exports::Guest for Test {
     fn add(a: &ComponentZ, b: &ComponentZ) -> wit_bindgen::Resource<ComponentZ> {
         wit_bindgen::Resource::new(ComponentZ { val: a.val + b.val })
@@ -78,3 +84,16 @@ impl exports::exports::GuestZ for ComponentZ {
         self.val
     }
 }
+
+impl exports::exports::GuestKebabCase for ComponentKebabCase {
+    fn new(a: u32) -> Self {
+        Self { val: a }
+    }
+    fn get_a(&self) -> u32 {
+        self.val
+    }
+
+    fn take_owned(k: OwnKebabCase) -> u32 {
+        k.get_a()
+    }
+}

tests/runtime/resources/world.wit

@@ -25,6 +25,12 @@ world resources {
 
     add: func(a: borrow<z>, b: borrow<z>) -> own<z>;
 
+    resource kebab-case {
+      constructor(a: u32);
+      get-a: func() -> u32;
+      take-owned: static func(k: own<kebab-case>) -> u32;
+    }
+
     test-imports: func() -> result<_, string>;
   }
 }