Complete support for rust 2024 edition (#1206)

* rust codegen tests: check with both edition 2021 and 2024

* Fixes to codegen to support 2024 edition

make various extern C blocks unsafe, and their call sites unsafe

all rust codegen tests pass for both edition 2021 and 2024.

---------

Co-authored-by: Alex Crichton <alex@alexcrichton.com>

Author: pchickey

crates/rust/src/bindgen.rs

@@ -98,13 +98,13 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
             "
                 #[cfg(target_arch = \"wasm32\")]
                 #[link(wasm_import_module = \"{module_name}\")]
-                extern \"C\" {{
+                unsafe extern \"C\" {{
                     #[link_name = \"{name}\"]
                     fn wit_import{tmp}{sig};
                 }}
 
                 #[cfg(not(target_arch = \"wasm32\"))]
-                extern \"C\" fn wit_import{tmp}{sig} {{ unreachable!() }}
+                unsafe extern \"C\" fn wit_import{tmp}{sig} {{ unreachable!() }}
             "
         );
         format!("wit_import{tmp}")
@@ -464,21 +464,21 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
                 let result = if is_own {
                     let name = self.r#gen.type_path(dealiased_resource, true);
-                    format!("{name}::from_handle({op} as u32)")
+                    format!("unsafe {{ {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)")
+                    format!("unsafe {{ {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);
+                            {tmp} = unsafe {{ {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!(
-                    "{async_support}::FutureReader::from_handle_and_vtable\
-                     ({op} as u32, &{path}wit_future::vtable{ordinal}::VTABLE)"
+                    "unsafe {{ {async_support}::FutureReader::from_handle_and_vtable\
+                     ({op} as u32, &{path}wit_future::vtable{ordinal}::VTABLE) }}"
                 ))
             }
 
@@ -897,10 +897,11 @@ 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, .. } => {
@@ -1027,7 +1028,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 uwriteln!(
                     self.src,
                     "\
-                            {func}({});
+                            unsafe {{ {func}({}) }};
                     ",
                     operands.join(", ")
                 );

crates/rust/src/interface.rs

@@ -224,11 +224,11 @@ unsafe fn _resource_new(val: *mut u8) -> u32
     #[cfg(target_arch = "wasm32")]
     {{
         #[link(wasm_import_module = "[export]{module}")]
-        extern "C" {{
+        unsafe extern "C" {{
             #[link_name = "[resource-new]{resource_name}"]
             fn new(_: *mut u8) -> u32;
         }}
-        new(val)
+        unsafe {{ new(val) }}
     }}
 }}
 
@@ -245,7 +245,7 @@ fn _resource_rep(handle: u32) -> *mut u8
     #[cfg(target_arch = "wasm32")]
     {{
         #[link(wasm_import_module = "[export]{module}")]
-        extern "C" {{
+        unsafe extern "C" {{
             #[link_name = "[resource-rep]{resource_name}"]
             fn rep(_: u32) -> *mut u8;
         }}
@@ -602,7 +602,7 @@ pub mod vtable{ordinal} {{
 
     #[cfg(target_arch = "wasm32")]
     #[link(wasm_import_module = "{module}")]
-    extern "C" {{
+    unsafe extern "C" {{
         #[link_name = "[future-new-{index}]{func_name}"]
         fn new() -> u32;
         #[link_name = "[future-cancel-write-{index}]{func_name}"]
@@ -784,7 +784,7 @@ pub mod vtable{ordinal} {{
 
     #[cfg(target_arch = "wasm32")]
     #[link(wasm_import_module = "{module}")]
-    extern "C" {{
+    unsafe extern "C" {{
         #[link_name = "[stream-new-{index}]{func_name}"]
         fn new() -> u32;
         #[link_name = "[stream-cancel-write-{index}]{func_name}"]
@@ -2472,7 +2472,7 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
                         #[doc(hidden)]
                         pub unsafe fn from_handle(handle: u32) -> Self {{
                             Self {{
-                                handle: {resource}::from_handle(handle),
+                                handle: unsafe {{ {resource}::from_handle(handle) }},
                             }}
                         }}
 
@@ -2545,7 +2545,7 @@ impl {camel} {{
     #[doc(hidden)]
     pub unsafe fn from_handle(handle: u32) -> Self {{
         Self {{
-            handle: {resource}::from_handle(handle),
+            handle: unsafe {{ {resource}::from_handle(handle) }},
         }}
     }}
 
@@ -2578,7 +2578,7 @@ impl {camel} {{
     #[doc(hidden)]
     pub unsafe fn dtor<T: 'static>(handle: *mut u8) {{
         Self::type_guard::<T>();
-        let _ = {box_path}::from_raw(handle as *mut _{camel}Rep<T>);
+        let _ = unsafe {{ {box_path}::from_raw(handle as *mut _{camel}Rep<T>) }};
     }}
 
     fn as_ptr<T: Guest{camel}>(&self) -> *mut _{camel}Rep<T> {{
@@ -2637,12 +2637,12 @@ impl<'a> {camel}Borrow<'a>{{
                          #[cfg(target_arch = "wasm32")]
                          {{
                              #[link(wasm_import_module = "{wasm_import_module}")]
-                             extern "C" {{
+                             unsafe extern "C" {{
                                  #[link_name = "[resource-drop]{name}"]
                                  fn drop(_: u32);
                              }}
 
-                             drop(_handle);
+                             unsafe {{ drop(_handle) }};
                          }}
                      }}
                 }}

crates/rust/src/lib.rs

@@ -589,7 +589,7 @@ pub unsafe fn invalid_enum_discriminant<T>() -> T {
     if cfg!(debug_assertions) {
         panic!(\"invalid enum discriminant\")
     } else {
-        core::hint::unreachable_unchecked()
+        unsafe { core::hint::unreachable_unchecked() }
     }
 }
                     ",

crates/test/src/rust.rs

@@ -142,7 +142,7 @@ path = 'lib.rs'
     }
 
     fn compile(&self, runner: &Runner<'_>, compile: &Compile) -> Result<()> {
-        let mut cmd = runner.rustc();
+        let mut cmd = runner.rustc(Edition::E2021);
 
         // If this rust target doesn't natively produce a component then place
         // the compiler output in a temporary location which is componentized
@@ -181,15 +181,21 @@ path = 'lib.rs'
     }
 
     fn verify(&self, runner: &Runner<'_>, verify: &Verify<'_>) -> Result<()> {
-        let mut cmd = runner.rustc();
         let bindings = verify
             .bindings_dir
             .join(format!("{}.rs", verify.world.to_snake_case()));
-        cmd.arg(&bindings)
-            .arg("--crate-type=rlib")
-            .arg("-o")
-            .arg(verify.artifacts_dir.join("tmp"));
-        runner.run_command(&mut cmd)?;
+        let test_edition = |edition: Edition| -> Result<()> {
+            let mut cmd = runner.rustc(edition);
+            cmd.arg(&bindings)
+                .arg("--crate-type=rlib")
+                .arg("-o")
+                .arg(verify.artifacts_dir.join("tmp"));
+            runner.run_command(&mut cmd)?;
+            Ok(())
+        };
+
+        test_edition(Edition::E2021)?;
+        test_edition(Edition::E2024)?;
 
         // If bindings are generated in `#![no_std]` mode then verify that it
         // compiles as such.
@@ -208,7 +214,7 @@ include!(env!("BINDINGS"));
 mod core {}
                 "#,
             )?;
-            let mut cmd = runner.rustc();
+            let mut cmd = runner.rustc(Edition::E2021);
             cmd.arg(&no_std_root)
                 .env("BINDINGS", &bindings)
                 .arg("--crate-type=rlib")
@@ -220,23 +226,31 @@ mod core {}
     }
 }
 
+enum Edition {
+    E2021,
+    E2024,
+}
+
 impl Runner<'_> {
-    fn rustc(&self) -> Command {
+    fn rustc(&self, edition: Edition) -> Command {
         let state = self.rust_state.as_ref().unwrap();
         let opts = &self.opts.rust;
         let mut cmd = Command::new("rustc");
-        cmd.arg("--edition=2021")
-            .arg(&format!(
-                "--extern=wit_bindgen={}",
-                state.wit_bindgen_rlib.display()
-            ))
-            .arg(&format!(
-                "--extern=futures={}",
-                state.futures_rlib.display()
-            ))
-            .arg("--target")
-            .arg(&opts.rust_target)
-            .arg("-Cdebuginfo=1");
+        cmd.arg(match edition {
+            Edition::E2021 => "--edition=2021",
+            Edition::E2024 => "--edition=2024",
+        })
+        .arg(&format!(
+            "--extern=wit_bindgen={}",
+            state.wit_bindgen_rlib.display()
+        ))
+        .arg(&format!(
+            "--extern=futures={}",
+            state.futures_rlib.display()
+        ))
+        .arg("--target")
+        .arg(&opts.rust_target)
+        .arg("-Cdebuginfo=1");
         for dep in state.wit_bindgen_deps.iter() {
             cmd.arg(&format!("-Ldependency={}", dep.display()));
         }