Squash more warnings in generated Rust code (#1214)

Add `-Dwarnings` to the codegen tests and fixup various issues around
`unsafe` and such by shuffling around `unsafe` blocks.

Author: alexcrichton

crates/guest-rust/rt/src/async_support/stream_support.rs

@@ -330,7 +330,7 @@ impl<T> StreamReader<T> {
     }
 
     #[doc(hidden)]
-    pub fn from_handle_and_vtable(handle: u32, vtable: &'static StreamVtable<T>) -> Self {
+    pub unsafe fn from_handle_and_vtable(handle: u32, vtable: &'static StreamVtable<T>) -> Self {
         super::with_entry(handle, |entry| match entry {
             Entry::Vacant(entry) => {
                 entry.insert(Handle::Read);

crates/rust/src/bindgen.rs

@@ -464,21 +464,21 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
                 let result = if is_own {
                     let name = self.r#gen.type_path(dealiased_resource, true);
-                    format!("unsafe {{ {name}::from_handle({op} as u32) }}")
+                    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!("unsafe {{ {name}Borrow::lift({op} as u32 as usize) }}")
+                    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} = unsafe {{ {name}::from_handle({op} as u32) }};
+                            {tmp} = {name}::from_handle({op} as u32);
                             &{tmp}
                         }}"
                     )
@@ -509,8 +509,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     .unwrap();
                 let path = self.r#gen.path_to_root();
                 results.push(format!(
-                    "unsafe {{ {async_support}::FutureReader::from_handle_and_vtable\
-                     ({op} as u32, &{path}wit_future::vtable{ordinal}::VTABLE) }}"
+                    "{async_support}::FutureReader::from_handle_and_vtable\
+                     ({op} as u32, &{path}wit_future::vtable{ordinal}::VTABLE)"
                 ))
             }
 
@@ -897,11 +897,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     self.push_str("let ret = ");
                     results.push("ret".to_string());
                 }
-                self.push_str("unsafe { ");
                 self.push_str(&func);
                 self.push_str("(");
                 self.push_str(&operands.join(", "));
-                self.push_str(") };\n");
+                self.push_str(");\n");
             }
 
             Instruction::AsyncCallWasm { name, .. } => {
@@ -1025,13 +1024,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             Instruction::AsyncCallReturn { name, params } => {
                 let func = self.declare_import(name, params, &[]);
 
-                uwriteln!(
-                    self.src,
-                    "\
-                            unsafe {{ {func}({}) }};
-                    ",
-                    operands.join(", ")
-                );
+                uwriteln!(self.src, "{func}({});", operands.join(", "));
                 self.emit_cleanup();
                 self.src.push_str("});\n");
             }

crates/rust/src/interface.rs

@@ -940,12 +940,12 @@ pub mod vtable{ordinal} {{
             self.src,
             "\
                 #[doc(hidden)]
-                #[allow(non_snake_case)]
+                #[allow(non_snake_case, unused_unsafe)]
                 pub unsafe fn _export_{name_snake}_cabi<T: {trait_name}>\
             ",
         );
         let params = self.print_export_sig(func, async_);
-        self.push_str(" {");
+        self.push_str(" { unsafe {");
 
         if !self.r#gen.opts.disable_run_ctors_once_workaround {
             let run_ctors_once = self.path_to_run_ctors_once();
@@ -1004,7 +1004,7 @@ pub mod vtable{ordinal} {{
             self.src.push_str("\n");
         }
         self.src.push_str(&String::from(src));
-        self.src.push_str("}\n");
+        self.src.push_str("} }\n");
 
         if async_ {
             let async_support = self.r#gen.async_support_path();
@@ -1030,7 +1030,7 @@ pub mod vtable{ordinal} {{
                 "
             );
             let params = self.print_post_return_sig(func);
-            self.src.push_str("{\n");
+            self.src.push_str("{ unsafe {\n");
 
             let mut f = FunctionBindgen::new(self, params, async_, self.wasm_import_module, false);
             abi::post_return(f.r#gen.resolve, func, &mut f, async_);
@@ -1043,7 +1043,7 @@ pub mod vtable{ordinal} {{
             assert!(!needs_cleanup_list);
             assert!(handle_decls.is_empty());
             self.src.push_str(&String::from(src));
-            self.src.push_str("}\n");
+            self.src.push_str("} }\n");
         }
     }
 
@@ -1228,6 +1228,7 @@ pub mod vtable{ordinal} {{
                 sig.self_arg = Some("&self".into());
                 sig.self_is_first_param = true;
             }
+            self.src.push_str("#[allow(unused_variables)]\n");
             self.print_signature(func, true, &sig);
             self.src.push_str("{ unreachable!() }\n");
         }
@@ -1307,6 +1308,10 @@ pub mod vtable{ordinal} {{
         // TODO: re-add this when docs are back
         // self.rustdoc_params(&func.results, "Return");
 
+        // TODO: should probably return `impl Future` in traits instead of
+        // having an `async fn` but that'll require more plumbing here.
+        self.push_str("#[allow(async_fn_in_trait)]\n");
+
         if !sig.private {
             self.push_str("pub ");
         }
@@ -2717,7 +2722,7 @@ impl<'a> {camel}Borrow<'a>{{
                     #[doc(hidden)]
                     pub unsafe fn _lift(val: {repr}) -> {name} {{
                         if !cfg!(debug_assertions) {{
-                            return ::core::mem::transmute(val);
+                            return unsafe {{ ::core::mem::transmute(val) }};
                         }}
 
                         match val {{

crates/rust/src/lib.rs

@@ -560,8 +560,10 @@ pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) {
     if size == 0 {
         return;
     }
-    let layout = alloc::Layout::from_size_align_unchecked(size, align);
-    alloc::dealloc(ptr, layout);
+    unsafe {
+        let layout = alloc::Layout::from_size_align_unchecked(size, align);
+        alloc::dealloc(ptr, layout);
+    }
 }
                     ",
                 );
@@ -575,7 +577,7 @@ pub unsafe fn string_lift(bytes: Vec<u8>) -> String {
     if cfg!(debug_assertions) {
         String::from_utf8(bytes).unwrap()
     } else {
-        String::from_utf8_unchecked(bytes)
+        unsafe { String::from_utf8_unchecked(bytes) }
     }
 }
                     ",
@@ -603,7 +605,7 @@ pub unsafe fn char_lift(val: u32) -> char {
     if cfg!(debug_assertions) {
         core::char::from_u32(val).unwrap()
     } else {
-        core::char::from_u32_unchecked(val)
+        unsafe { core::char::from_u32_unchecked(val) }
     }
 }
                     ",

crates/test/src/lib.rs

@@ -441,6 +441,11 @@ impl Runner<'_> {
             TestKind::Runtime(_) => None,
             TestKind::Codegen(p) => Some((name, p)),
         }) {
+            if let Some(filter) = &self.opts.filter {
+                if !filter.is_match(name) {
+                    continue;
+                }
+            }
             let config = match fs::read_to_string(test) {
                 Ok(wit) => config::parse_test_config::<config::WitConfig>(&wit, "//@")
                     .with_context(|| format!("failed to parse test config from {test:?}"))?,
@@ -459,20 +464,29 @@ impl Runner<'_> {
                     continue;
                 }
 
+                let mut args = Vec::new();
+                for arg in language.obj().default_bindgen_args_for_codegen() {
+                    args.push(arg.to_string());
+                }
+
                 codegen_tests.push((
                     language.clone(),
                     test,
                     name.to_string(),
-                    Vec::new(),
+                    args.clone(),
                     config.clone(),
                 ));
 
-                for (args_kind, args) in language.obj().codegen_test_variants() {
+                for (args_kind, new_args) in language.obj().codegen_test_variants() {
+                    let mut args = args.clone();
+                    for arg in new_args.iter() {
+                        args.push(arg.to_string());
+                    }
                     codegen_tests.push((
                         language.clone(),
                         test,
                         format!("{name}-{args_kind}"),
-                        args.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                        args,
                         config.clone(),
                     ));
                 }
@@ -982,6 +996,12 @@ trait LanguageMethods {
         &[]
     }
 
+    /// Same as `default_bindgen_args` but specifically applied during codegen
+    /// tests, such as generating stub impls by default.
+    fn default_bindgen_args_for_codegen(&self) -> &[&str] {
+        &[]
+    }
+
     /// Returns the name of this bindings generator when passed to
     /// `wit-bindgen`.
     ///

crates/test/src/rust.rs

@@ -72,7 +72,11 @@ impl LanguageMethods for Rust {
     }
 
     fn default_bindgen_args(&self) -> &[&str] {
-        &["--generate-all"]
+        &["--generate-all", "--format"]
+    }
+
+    fn default_bindgen_args_for_codegen(&self) -> &[&str] {
+        &["--stubs"]
     }
 
     fn prepare(&self, runner: &mut Runner<'_>) -> Result<()> {
@@ -162,7 +166,6 @@ path = 'lib.rs'
                     .join(format!("{}.rs", compile.component.kind)),
             )
             .arg(compile.component.path.file_name().unwrap())
-            .arg("-Dwarnings")
             .arg("-o")
             .arg(&output);
         match compile.component.kind {
@@ -250,6 +253,7 @@ impl Runner<'_> {
         ))
         .arg("--target")
         .arg(&opts.rust_target)
+        .arg("-Dwarnings")
         .arg("-Cdebuginfo=1");
         for dep in state.wit_bindgen_deps.iter() {
             cmd.arg(&format!("-Ldependency={}", dep.display()));