fix(rust): Use type_path for exported borrowed resource (#1534)

* fix borrowed handle lift

* rename export_cabi trait name from T to T_

* fix

Author: chenyan2002

crates/rust/src/bindgen.rs

@@ -395,20 +395,14 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
                 let dealiased_resource = dealias(resolve, *resource);
 
+                let name = self.r#gen.type_path(dealiased_resource, true);
                 let result = if is_own {
-                    let name = self.r#gen.type_path(dealiased_resource, true);
                     format!("{name}::from_handle({op} as u32)")
                 } else if self.r#gen.is_exported_resource(*resource) {
-                    let name = resolve.types[*resource]
-                        .name
-                        .as_deref()
-                        .unwrap()
-                        .to_upper_camel_case();
                     format!("{name}Borrow::lift({op} as u32 as usize)")
                 } else {
                     let tmp = format!("handle{}", self.tmp());
                     self.handle_decls.push(format!("let {tmp};"));
-                    let name = self.r#gen.type_path(dealiased_resource, true);
                     format!(
                         "{{\n
                             {tmp} = {name}::from_handle({op} as u32);
@@ -871,14 +865,14 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 self.push_str(&prev_src);
                 let constructor_type = match &func.kind {
                     FunctionKind::Freestanding | FunctionKind::AsyncFreestanding => {
-                        self.push_str(&format!("T::{}", to_rust_ident(func.item_name())));
+                        self.push_str(&format!("T_::{}", to_rust_ident(func.item_name())));
                         None
                     }
                     FunctionKind::Method(_)
                     | FunctionKind::Static(_)
                     | FunctionKind::AsyncMethod(_)
                     | FunctionKind::AsyncStatic(_) => {
-                        self.push_str(&format!("T::{}", to_rust_ident(func.item_name())));
+                        self.push_str(&format!("T_::{}", to_rust_ident(func.item_name())));
                         None
                     }
                     FunctionKind::Constructor(ty) => {
@@ -892,10 +886,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
                         match return_type {
                             ConstructorReturnType::Self_ => {
-                                self.push_str(&format!("{ty}::new(T::new"));
+                                self.push_str(&format!("{ty}::new(T_::new"));
                             }
                             ConstructorReturnType::Result { .. } => {
-                                self.push_str(&format!("T::new"));
+                                self.push_str(&format!("T_::new"));
                             }
                         }
 

crates/rust/src/interface.rs

@@ -1077,7 +1077,7 @@ unsafe fn call_import(&mut self, _params: Self::ParamsLower, _results: *mut u8)
             "\
                 #[doc(hidden)]
                 #[allow(non_snake_case, unused_unsafe)]
-                pub unsafe fn _export_{name_snake}_cabi<T: {trait_name}>\
+                pub unsafe fn _export_{name_snake}_cabi<T_: {trait_name}>\
             ",
         );
         let params = self.print_export_sig(func, async_);
@@ -1163,7 +1163,7 @@ unsafe fn call_import(&mut self, _params: Self::ParamsLower, _results: *mut u8)
                 "\
                     #[doc(hidden)]
                     #[allow(non_snake_case)]
-                    pub unsafe fn __post_return_{name_snake}<T: {trait_name}>\
+                    pub unsafe fn __post_return_{name_snake}<T_: {trait_name}>\
                 "
             );
             let params = self.print_post_return_sig(func);

tests/codegen/issue1466.wit

@@ -0,0 +1,19 @@
+package foo:foo;
+
+interface original {
+  resource extra-options;
+  record options {
+    extra: option<borrow<extra-options>>,
+  }
+}
+
+interface adapter {
+  use original.{options};
+  variant t { a }
+  f: func(x: options, t: t);
+}
+
+world root {
+  export original;
+  export adapter;
+}