diff --git a/Cargo.lock b/Cargo.lock
index bdc68d6eb..b55588bdf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2591,7 +2591,6 @@ dependencies = [
  "wit-bindgen-markdown",
  "wit-bindgen-moonbit",
  "wit-bindgen-rust",
- "wit-bindgen-teavm-java",
  "wit-component",
  "wit-parser 0.227.0",
 ]
@@ -2699,19 +2698,6 @@ dependencies = [
  "wit-bindgen-rust",
 ]
 
-[[package]]
-name = "wit-bindgen-teavm-java"
-version = "0.40.0"
-dependencies = [
- "anyhow",
- "clap",
- "heck 0.5.0",
- "test-helpers",
- "wasm-metadata",
- "wit-bindgen-core",
- "wit-component",
-]
-
 [[package]]
 name = "wit-component"
 version = "0.227.0"
diff --git a/crates/rust/src/bindgen.rs b/crates/rust/src/bindgen.rs
index 7ca7094a9..d180e66c9 100644
--- a/crates/rust/src/bindgen.rs
+++ b/crates/rust/src/bindgen.rs
@@ -6,7 +6,7 @@ use wit_bindgen_core::abi::{Bindgen, Instruction, LiftLower, WasmType};
 use wit_bindgen_core::{dealias, uwrite, uwriteln, wit_parser::*, Source};
 
 pub(super) struct FunctionBindgen<'a, 'b> {
-    pub gen: &'b mut InterfaceGenerator<'a>,
+    pub r#gen: &'b mut InterfaceGenerator<'a>,
     params: Vec<String>,
     async_: bool,
     wasm_import_module: &'b str,
@@ -28,14 +28,14 @@ pub const POINTER_SIZE_EXPRESSION: &str = "::core::mem::size_of::<*const u8>()";
 
 impl<'a, 'b> FunctionBindgen<'a, 'b> {
     pub(super) fn new(
-        gen: &'b mut InterfaceGenerator<'a>,
+        r#gen: &'b mut InterfaceGenerator<'a>,
         params: Vec<String>,
         async_: bool,
         wasm_import_module: &'b str,
         always_owned: bool,
     ) -> FunctionBindgen<'a, 'b> {
         FunctionBindgen {
-            gen,
+            r#gen,
             params,
             async_,
             wasm_import_module,
@@ -60,13 +60,13 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
         }
         self.emitted_cleanup = true;
         for (ptr, layout) in mem::take(&mut self.cleanup) {
-            let alloc = self.gen.path_to_std_alloc_module();
+            let alloc = self.r#gen.path_to_std_alloc_module();
             self.push_str(&format!(
                 "if {layout}.size() != 0 {{\n{alloc}::dealloc({ptr}.cast(), {layout});\n}}\n"
             ));
         }
         if self.needs_cleanup_list {
-            let alloc = self.gen.path_to_std_alloc_module();
+            let alloc = self.r#gen.path_to_std_alloc_module();
             self.push_str(&format!(
                 "for (ptr, layout) in cleanup_list {{\n
                     if layout.size() != 0 {{\n
@@ -208,11 +208,11 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
                 LiftLower::LowerArgsLiftResults => false,
                 LiftLower::LiftArgsLowerResults => true,
             };
-        self.gen.type_path(id, owned)
+        self.r#gen.type_path(id, owned)
     }
 
     fn typename_lift(&self, id: TypeId) -> String {
-        self.gen.type_path(id, true)
+        self.r#gen.type_path(id, true)
     }
 
     fn push_str(&mut self, s: &str) {
@@ -226,7 +226,7 @@ impl<'a, 'b> FunctionBindgen<'a, 'b> {
     }
 
     fn lift_lower(&self) -> LiftLower {
-        if self.gen.in_import {
+        if self.r#gen.in_import {
             LiftLower::LowerArgsLiftResults
         } else {
             LiftLower::LiftArgsLowerResults
@@ -285,9 +285,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             // hand out a null pointer. This can happen with async for example
             // when the params or results are zero-sized.
             uwrite!(self.src, "let ptr{tmp} = core::ptr::null_mut::<u8>();");
-        } else if self.gen.in_import {
+        } else if self.r#gen.in_import {
             // Import return areas are stored on the stack since this stack
-            // frame will be around for the entire function call.
             self.import_return_pointer_area_size = self.import_return_pointer_area_size.max(size);
             self.import_return_pointer_area_align =
                 self.import_return_pointer_area_align.max(align);
@@ -299,8 +298,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             // Export return areas are stored in `static` memory as they need to
             // persist beyond the function call itself (and are cleaned-up in
             // `post-return`).
-            self.gen.return_pointer_area_size = self.gen.return_pointer_area_size.max(size);
-            self.gen.return_pointer_area_align = self.gen.return_pointer_area_align.max(align);
+            self.r#gen.return_pointer_area_size = self.r#gen.return_pointer_area_size.max(size);
+            self.r#gen.return_pointer_area_align = self.r#gen.return_pointer_area_align.max(align);
             uwriteln!(
                 self.src,
                 "let ptr{tmp} = _RET_AREA.0.as_mut_ptr().cast::<u8>();"
@@ -310,7 +309,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
     }
 
     fn sizes(&self) -> &SizeAlign {
-        &self.gen.sizes
+        &self.r#gen.sizes
     }
 
     fn is_list_canonical(&self, resolve: &Resolve, ty: &Type) -> bool {
@@ -321,7 +320,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             // Note that tuples in Rust are not ABI-compatible with component
             // model tuples, so those are exempted here from canonical lists.
             Type::Id(id) => {
-                let info = self.gen.gen.types.get(*id);
+                let info = self.r#gen.r#gen.types.get(*id);
                 !info.has_resource && !info.has_tuple
             }
             _ => true,
@@ -363,7 +362,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
 
             Instruction::I64FromU64 | Instruction::I64FromS64 => {
                 let s = operands.pop().unwrap();
-                results.push(format!("{}({s})", self.gen.path_to_as_i64()));
+                results.push(format!("{}({s})", self.r#gen.path_to_as_i64()));
             }
             Instruction::I32FromChar
             | Instruction::I32FromU8
@@ -373,16 +372,16 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             | Instruction::I32FromU32
             | Instruction::I32FromS32 => {
                 let s = operands.pop().unwrap();
-                results.push(format!("{}({s})", self.gen.path_to_as_i32()));
+                results.push(format!("{}({s})", self.r#gen.path_to_as_i32()));
             }
 
             Instruction::CoreF32FromF32 => {
                 let s = operands.pop().unwrap();
-                results.push(format!("{}({s})", self.gen.path_to_as_f32()));
+                results.push(format!("{}({s})", self.r#gen.path_to_as_f32()));
             }
             Instruction::CoreF64FromF64 => {
                 let s = operands.pop().unwrap();
-                results.push(format!("{}({s})", self.gen.path_to_as_f64()));
+                results.push(format!("{}({s})", self.r#gen.path_to_as_f64()));
             }
             Instruction::F32FromCoreF32
             | Instruction::F64FromCoreF64
@@ -399,7 +398,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             Instruction::CharFromI32 => {
                 results.push(format!(
                     "{}({} as u32)",
-                    self.gen.path_to_char_lift(),
+                    self.r#gen.path_to_char_lift(),
                     operands[0]
                 ));
             }
@@ -412,7 +411,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             Instruction::BoolFromI32 => {
                 results.push(format!(
                     "{}({} as u8)",
-                    self.gen.path_to_bool_lift(),
+                    self.r#gen.path_to_bool_lift(),
                     operands[0]
                 ));
             }
@@ -426,7 +425,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             }
             Instruction::FlagsLift { flags, ty, .. } => {
                 let repr = RustFlagsRepr::new(flags);
-                let name = self.gen.type_path(*ty, true);
+                let name = self.r#gen.type_path(*ty, true);
                 let mut result = format!("{name}::empty()");
                 for (i, op) in operands.iter().enumerate() {
                     result.push_str(&format!(
@@ -464,9 +463,9 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 let dealiased_resource = dealias(resolve, *resource);
 
                 let result = if is_own {
-                    let name = self.gen.type_path(dealiased_resource, true);
+                    let name = self.r#gen.type_path(dealiased_resource, true);
                     format!("{name}::from_handle({op} as u32)")
-                } else if self.gen.is_exported_resource(*resource) {
+                } else if self.r#gen.is_exported_resource(*resource) {
                     let name = resolve.types[*resource]
                         .name
                         .as_deref()
@@ -476,7 +475,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 } else {
                     let tmp = format!("handle{}", self.tmp());
                     self.handle_decls.push(format!("let {tmp};"));
-                    let name = self.gen.type_path(dealiased_resource, true);
+                    let name = self.r#gen.type_path(dealiased_resource, true);
                     format!(
                         "{{\n
                             {tmp} = {name}::from_handle({op} as u32);
@@ -493,17 +492,22 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             }
 
             Instruction::FutureLift { payload, .. } => {
-                let async_support = self.gen.gen.async_support_path();
+                let async_support = self.r#gen.r#gen.async_support_path();
                 let op = &operands[0];
                 let name = payload
                     .as_ref()
                     .map(|ty| {
-                        self.gen
+                        self.r#gen
                             .type_name_owned_with_id(ty, Identifier::StreamOrFuturePayload)
                     })
                     .unwrap_or_else(|| "()".into());
-                let ordinal = self.gen.gen.future_payloads.get_index_of(&name).unwrap();
-                let path = self.gen.path_to_root();
+                let ordinal = self
+                    .r#gen
+                    .r#gen
+                    .future_payloads
+                    .get_index_of(&name)
+                    .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)"
@@ -516,17 +520,22 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             }
 
             Instruction::StreamLift { payload, .. } => {
-                let async_support = self.gen.gen.async_support_path();
+                let async_support = self.r#gen.r#gen.async_support_path();
                 let op = &operands[0];
                 let name = payload
                     .as_ref()
                     .map(|ty| {
-                        self.gen
+                        self.r#gen
                             .type_name_owned_with_id(ty, Identifier::StreamOrFuturePayload)
                     })
                     .unwrap_or_else(|| "()".into());
-                let ordinal = self.gen.gen.stream_payloads.get_index_of(&name).unwrap();
-                let path = self.gen.path_to_root();
+                let ordinal = self
+                    .r#gen
+                    .r#gen
+                    .stream_payloads
+                    .get_index_of(&name)
+                    .unwrap();
+                let path = self.r#gen.path_to_root();
                 results.push(format!(
                     "{async_support}::StreamReader::from_handle_and_vtable\
                      ({op} as u32, &{path}wit_stream::vtable{ordinal}::VTABLE)"
@@ -539,7 +548,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             }
 
             Instruction::ErrorContextLift { .. } => {
-                let async_support = self.gen.gen.async_support_path();
+                let async_support = self.r#gen.r#gen.async_support_path();
                 let op = &operands[0];
                 results.push(format!(
                     "{async_support}::ErrorContext::from_handle({op} as u32)"
@@ -668,7 +677,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                         }}
                         _ => {invalid}(),
                     }}",
-                    invalid = self.gen.path_to_invalid_enum_discriminant(),
+                    invalid = self.r#gen.path_to_invalid_enum_discriminant(),
                 ));
             }
 
@@ -707,7 +716,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                         }}
                         _ => {invalid}(),
                     }}",
-                    invalid = self.gen.path_to_invalid_enum_discriminant(),
+                    invalid = self.r#gen.path_to_invalid_enum_discriminant(),
                 ));
             }
 
@@ -716,7 +725,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             }
 
             Instruction::EnumLift { enum_, ty, .. } => {
-                let name = self.gen.type_path(*ty, true);
+                let name = self.r#gen.type_path(*ty, true);
                 let repr = int_repr(enum_.tag());
                 let op = &operands[0];
                 let result = format!("{name}::_lift({op} as {repr})");
@@ -747,7 +756,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 let tmp = self.tmp();
                 let len = format!("len{}", tmp);
                 self.push_str(&format!("let {} = {};\n", len, operands[1]));
-                let vec = self.gen.path_to_vec();
+                let vec = self.r#gen.path_to_vec();
                 let result = format!(
                     "{vec}::from_raw_parts({}.cast(), {1}, {1})",
                     operands[0], len
@@ -776,7 +785,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             }
 
             Instruction::StringLift => {
-                let vec = self.gen.path_to_vec();
+                let vec = self.r#gen.path_to_vec();
                 let tmp = self.tmp();
                 let len = format!("len{}", tmp);
                 uwriteln!(self.src, "let {len} = {};", operands[1]);
@@ -785,15 +794,15 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     "let bytes{tmp} = {vec}::from_raw_parts({}.cast(), {len}, {len});",
                     operands[0],
                 );
-                if self.gen.gen.opts.raw_strings {
+                if self.r#gen.r#gen.opts.raw_strings {
                     results.push(format!("bytes{tmp}"));
                 } else {
-                    results.push(format!("{}(bytes{tmp})", self.gen.path_to_string_lift()));
+                    results.push(format!("{}(bytes{tmp})", self.r#gen.path_to_string_lift()));
                 }
             }
 
             Instruction::ListLower { element, realloc } => {
-                let alloc = self.gen.path_to_std_alloc_module();
+                let alloc = self.r#gen.path_to_std_alloc_module();
                 let body = self.blocks.pop().unwrap();
                 let tmp = self.tmp();
                 let vec = format!("vec{tmp}");
@@ -805,8 +814,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     operand0 = operands[0]
                 ));
                 self.push_str(&format!("let {len} = {vec}.len();\n"));
-                let size = self.gen.sizes.size(element);
-                let align = self.gen.sizes.align(element);
+                let size = self.r#gen.sizes.size(element);
+                let align = self.r#gen.sizes.align(element);
                 self.push_str(&format!(
                     "let {layout} = {alloc}::Layout::from_size_align_unchecked({vec}.len() * {}, {});\n",
                     size.format(POINTER_SIZE_EXPRESSION), align.format(POINTER_SIZE_EXPRESSION),
@@ -840,8 +849,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             Instruction::ListLift { element, .. } => {
                 let body = self.blocks.pop().unwrap();
                 let tmp = self.tmp();
-                let size = self.gen.sizes.size(element);
-                let align = self.gen.sizes.align(element);
+                let size = self.r#gen.sizes.size(element);
+                let align = self.r#gen.sizes.align(element);
                 let len = format!("len{tmp}");
                 let base = format!("base{tmp}");
                 let result = format!("result{tmp}");
@@ -853,7 +862,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     "let {len} = {operand1};\n",
                     operand1 = operands[1]
                 ));
-                let vec = self.gen.path_to_vec();
+                let vec = self.r#gen.path_to_vec();
                 self.push_str(&format!(
                     "let mut {result} = {vec}::with_capacity({len});\n",
                 ));
@@ -868,7 +877,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 uwriteln!(self.src, "{result}.push(e{tmp});");
                 uwriteln!(self.src, "}}");
                 results.push(result);
-                let dealloc = self.gen.path_to_cabi_dealloc();
+                let dealloc = self.r#gen.path_to_cabi_dealloc();
                 self.push_str(&format!(
                     "{dealloc}({base}, {len} * {size}, {align});\n",
                     size = size.format(POINTER_SIZE_EXPRESSION),
@@ -897,7 +906,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             Instruction::AsyncCallWasm { name, .. } => {
                 let func = self.declare_import(name, &[WasmType::Pointer; 2], &[WasmType::I32]);
 
-                let async_support = self.gen.gen.async_support_path();
+                let async_support = self.r#gen.r#gen.async_support_path();
                 let operands = operands.join(", ");
                 uwriteln!(
                     self.src,
@@ -931,7 +940,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                             .unwrap()
                             .to_upper_camel_case();
                         let call = if self.async_ {
-                            let async_support = self.gen.gen.async_support_path();
+                            let async_support = self.r#gen.r#gen.async_support_path();
                             format!("{async_support}::futures::FutureExt::map(T::new")
                         } else {
                             format!("{ty}::new(T::new",)
@@ -987,7 +996,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 } else {
                     params
                 };
-                let async_support = self.gen.gen.async_support_path();
+                let async_support = self.r#gen.r#gen.async_support_path();
                 // TODO: This relies on `abi::Generator` emitting
                 // `AsyncCallReturn` immediately after this instruction to
                 // complete the incomplete expression we generate here.  We
@@ -1222,7 +1231,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             Instruction::Malloc { .. } => unimplemented!(),
 
             Instruction::GuestDeallocate { size, align } => {
-                let dealloc = self.gen.path_to_cabi_dealloc();
+                let dealloc = self.r#gen.path_to_cabi_dealloc();
                 self.push_str(&format!(
                     "{dealloc}({op}, {size}, {align});\n",
                     op = operands[0],
@@ -1232,7 +1241,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             }
 
             Instruction::GuestDeallocateString => {
-                let dealloc = self.gen.path_to_cabi_dealloc();
+                let dealloc = self.r#gen.path_to_cabi_dealloc();
                 self.push_str(&format!(
                     "{dealloc}({op0}, {op1}, 1);\n",
                     op0 = operands[0],
@@ -1262,8 +1271,8 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             Instruction::GuestDeallocateList { element } => {
                 let body = self.blocks.pop().unwrap();
                 let tmp = self.tmp();
-                let size = self.gen.sizes.size(element);
-                let align = self.gen.sizes.align(element);
+                let size = self.r#gen.sizes.size(element);
+                let align = self.r#gen.sizes.align(element);
                 let len = format!("len{tmp}");
                 let base = format!("base{tmp}");
                 self.push_str(&format!(
@@ -1287,7 +1296,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     self.push_str(&body);
                     self.push_str("\n}\n");
                 }
-                let dealloc = self.gen.path_to_cabi_dealloc();
+                let dealloc = self.r#gen.path_to_cabi_dealloc();
                 self.push_str(&format!(
                     "{dealloc}({base}, {len} * {size}, {align});\n",
                     size = size.format(POINTER_SIZE_EXPRESSION),
diff --git a/crates/rust/src/interface.rs b/crates/rust/src/interface.rs
index 4e22346fc..58e47dba9 100644
--- a/crates/rust/src/interface.rs
+++ b/crates/rust/src/interface.rs
@@ -19,7 +19,7 @@ pub struct InterfaceGenerator<'a> {
     pub(super) identifier: Identifier<'a>,
     pub in_import: bool,
     pub sizes: SizeAlign,
-    pub(super) gen: &'a mut RustWasm,
+    pub(super) r#gen: &'a mut RustWasm,
     pub wasm_import_module: &'a str,
     pub resolve: &'a Resolve,
     pub return_pointer_area_size: ArchitectureSize,
@@ -153,11 +153,11 @@ impl<'i> InterfaceGenerator<'i> {
         }
 
         for func in funcs {
-            if self.gen.skip.contains(&func.name) {
+            if self.r#gen.skip.contains(&func.name) {
                 continue;
             }
 
-            let async_ = match &self.gen.opts.async_ {
+            let async_ = match &self.r#gen.opts.async_ {
                 AsyncConfig::None => false,
                 AsyncConfig::All => true,
                 AsyncConfig::Some { exports, .. } => {
@@ -284,7 +284,7 @@ fn _resource_rep(handle: u32) -> *mut u8
                 )
             }
         };
-        let (macro_export, use_vis) = if self.gen.opts.pub_export_macro {
+        let (macro_export, use_vis) = if self.r#gen.opts.pub_export_macro {
             ("#[macro_export]", "pub")
         } else {
             ("", "pub(crate)")
@@ -314,7 +314,7 @@ macro_rules! {macro_name} {{
             };
             self.generate_raw_cabi_export(func, &ty, "$($path_to_types)*", async_);
         }
-        let export_prefix = self.gen.opts.export_prefix.as_deref().unwrap_or("");
+        let export_prefix = self.r#gen.opts.export_prefix.as_deref().unwrap_or("");
         for name in resources_to_drop {
             let module = match self.identifier {
                 Identifier::Interface(_, key) => self.resolve.name_world_key(key),
@@ -331,9 +331,11 @@ macro_rules! {macro_name} {{
                     #[unsafe(export_name = "{export_prefix}{module}#[dtor]{name}")]
                     #[allow(non_snake_case)]
                     unsafe extern "C" fn dtor(rep: *mut u8) {{
-                        $($path_to_types)*::{camel}::dtor::<
-                            <$ty as $($path_to_types)*::Guest>::{camel}
-                        >(rep)
+                        unsafe {{
+                            $($path_to_types)*::{camel}::dtor::<
+                                <$ty as $($path_to_types)*::Guest>::{camel}
+                            >(rep)
+                        }}
                     }}
                 }};
                 "#
@@ -460,7 +462,7 @@ macro_rules! {macro_name} {{
         let docs = docs.trim_end();
 
         let path_to_root = self.path_to_root();
-        let used_static = if self.gen.opts.disable_custom_section_link_helpers {
+        let used_static = if self.r#gen.opts.disable_custom_section_link_helpers {
             String::new()
         } else {
             format!(
@@ -483,9 +485,9 @@ macro_rules! {macro_name} {{
 ",
         );
         let map = if self.in_import {
-            &mut self.gen.import_modules
+            &mut self.r#gen.import_modules
         } else {
-            &mut self.gen.export_modules
+            &mut self.r#gen.export_modules
         };
         map.push((module, module_path))
     }
@@ -505,7 +507,7 @@ macro_rules! {macro_name} {{
                     .unwrap_or_else(|| "$root".into())
             );
             let func_name = &func.name;
-            let async_support = self.gen.async_support_path();
+            let async_support = self.r#gen.async_support_path();
 
             match &self.resolve.types[ty].kind {
                 TypeDefKind::Future(payload_type) => {
@@ -515,8 +517,8 @@ macro_rules! {macro_name} {{
                         "()".into()
                     };
 
-                    if !self.gen.future_payloads.contains_key(&name) {
-                        let ordinal = self.gen.future_payloads.len();
+                    if !self.r#gen.future_payloads.contains_key(&name) {
+                        let ordinal = self.r#gen.future_payloads.len();
                         let (size, align) = if let Some(payload_type) = payload_type {
                             (
                                 self.sizes.size(payload_type),
@@ -629,7 +631,7 @@ pub mod vtable{ordinal} {{
                         "#,
                         );
 
-                        self.gen.future_payloads.insert(name, code);
+                        self.r#gen.future_payloads.insert(name, code);
                     }
                 }
                 TypeDefKind::Stream(payload_type) => {
@@ -639,8 +641,8 @@ pub mod vtable{ordinal} {{
                         "()".into()
                     };
 
-                    if !self.gen.stream_payloads.contains_key(&name) {
-                        let ordinal = self.gen.stream_payloads.len();
+                    if !self.r#gen.stream_payloads.contains_key(&name) {
+                        let ordinal = self.r#gen.stream_payloads.len();
                         let (size, align) = if let Some(payload_type) = payload_type {
                             (
                                 self.sizes.size(payload_type),
@@ -810,7 +812,7 @@ pub mod vtable{ordinal} {{
                         "#,
                         );
 
-                        self.gen.stream_payloads.insert(name, code);
+                        self.r#gen.stream_payloads.insert(name, code);
                     }
                 }
                 _ => unreachable!(),
@@ -821,13 +823,13 @@ pub mod vtable{ordinal} {{
     }
 
     fn generate_guest_import(&mut self, func: &Function, interface: Option<&WorldKey>) {
-        if self.gen.skip.contains(&func.name) {
+        if self.r#gen.skip.contains(&func.name) {
             return;
         }
 
         self.generate_payloads("", func, interface);
 
-        let async_ = match &self.gen.opts.async_ {
+        let async_ = match &self.r#gen.opts.async_ {
             AsyncConfig::None => false,
             AsyncConfig::All => true,
             AsyncConfig::Some { imports, .. } => imports.contains(&if let Some(key) = interface {
@@ -867,13 +869,13 @@ pub mod vtable{ordinal} {{
 
     fn lower_to_memory(&mut self, address: &str, value: &str, ty: &Type, module: &str) -> String {
         let mut f = FunctionBindgen::new(self, Vec::new(), true, module, true);
-        abi::lower_to_memory(f.gen.resolve, &mut f, address.into(), value.into(), ty);
+        abi::lower_to_memory(f.r#gen.resolve, &mut f, address.into(), value.into(), ty);
         format!("unsafe {{ {} }}", String::from(f.src))
     }
 
     fn lift_from_memory(&mut self, address: &str, value: &str, ty: &Type, module: &str) -> String {
         let mut f = FunctionBindgen::new(self, Vec::new(), true, module, true);
-        let result = abi::lift_from_memory(f.gen.resolve, &mut f, address.into(), ty);
+        let result = abi::lift_from_memory(f.r#gen.resolve, &mut f, address.into(), ty);
         format!(
             "let {value} = unsafe {{ {}\n{result} }};",
             String::from(f.src)
@@ -889,7 +891,7 @@ pub mod vtable{ordinal} {{
     ) {
         let mut f = FunctionBindgen::new(self, params, async_, module, false);
         abi::call(
-            f.gen.resolve,
+            f.r#gen.resolve,
             AbiVariant::GuestImport,
             LiftLower::LowerArgsLiftResults,
             func,
@@ -945,7 +947,7 @@ pub mod vtable{ordinal} {{
         let params = self.print_export_sig(func, async_);
         self.push_str(" {");
 
-        if !self.gen.opts.disable_run_ctors_once_workaround {
+        if !self.r#gen.opts.disable_run_ctors_once_workaround {
             let run_ctors_once = self.path_to_run_ctors_once();
             // Before executing any other code, use this function to run all
             // static constructors, if they have not yet been run. This is a
@@ -963,7 +965,7 @@ pub mod vtable{ordinal} {{
 
         let mut f = FunctionBindgen::new(self, params, async_, self.wasm_import_module, false);
         abi::call(
-            f.gen.resolve,
+            f.r#gen.resolve,
             AbiVariant::GuestExport,
             LiftLower::LiftArgsLowerResults,
             func,
@@ -1005,14 +1007,16 @@ pub mod vtable{ordinal} {{
         self.src.push_str("}\n");
 
         if async_ {
-            let async_support = self.gen.async_support_path();
+            let async_support = self.r#gen.async_support_path();
             uwrite!(
                 self.src,
                 "\
                     #[doc(hidden)]
                     #[allow(non_snake_case)]
                     pub unsafe fn __callback_{name_snake}(ctx: *mut u8, event0: i32, event1: i32, event2: i32) -> i32 {{
-                        {async_support}::callback(ctx, event0, event1, event2)
+                        unsafe {{
+                            {async_support}::callback(ctx, event0, event1, event2)
+                        }}
                     }}
                 "
             );
@@ -1029,7 +1033,7 @@ pub mod vtable{ordinal} {{
             self.src.push_str("{\n");
 
             let mut f = FunctionBindgen::new(self, params, async_, self.wasm_import_module, false);
-            abi::post_return(f.gen.resolve, func, &mut f, async_);
+            abi::post_return(f.r#gen.resolve, func, &mut f, async_);
             let FunctionBindgen {
                 needs_cleanup_list,
                 src,
@@ -1056,7 +1060,7 @@ pub mod vtable{ordinal} {{
             Identifier::World(_) => None,
             Identifier::StreamOrFuturePayload => unreachable!(),
         };
-        let export_prefix = self.gen.opts.export_prefix.as_deref().unwrap_or("");
+        let export_prefix = self.r#gen.opts.export_prefix.as_deref().unwrap_or("");
         let export_name = func.legacy_core_export_name(wasm_module_export_name.as_deref());
         let export_name = if async_ {
             format!("[async-lift]{export_name}")
@@ -1075,19 +1079,21 @@ pub mod vtable{ordinal} {{
         self.push_str(" {\n");
         uwriteln!(
             self.src,
-            "{path_to_self}::_export_{name_snake}_cabi::<{ty}>({})",
+            "unsafe {{ {path_to_self}::_export_{name_snake}_cabi::<{ty}>({}) }}",
             params.join(", ")
         );
         self.push_str("}\n");
 
-        let export_prefix = self.gen.opts.export_prefix.as_deref().unwrap_or("");
+        let export_prefix = self.r#gen.opts.export_prefix.as_deref().unwrap_or("");
         if async_ {
             uwrite!(
                 self.src,
                 "\
                     #[unsafe(export_name = \"{export_prefix}[callback]{export_name}\")]
                     unsafe extern \"C\" fn _callback_{name_snake}(ctx: *mut u8, event0: i32, event1: i32, event2: i32) -> i32 {{
-                        {path_to_self}::__callback_{name_snake}(ctx, event0, event1, event2)
+                        unsafe {{
+                            {path_to_self}::__callback_{name_snake}(ctx, event0, event1, event2)
+                        }}
                     }}
                 "
             );
@@ -1103,7 +1109,7 @@ pub mod vtable{ordinal} {{
             self.src.push_str("{\n");
             uwriteln!(
                 self.src,
-                "{path_to_self}::__post_return_{name_snake}::<{ty}>({})",
+                "unsafe {{ {path_to_self}::__post_return_{name_snake}::<{ty}>({}) }}",
                 params.join(", ")
             );
             self.src.push_str("}\n");
@@ -1198,10 +1204,10 @@ pub mod vtable{ordinal} {{
         self.src.push_str(extra_trait_items);
 
         for func in funcs {
-            if self.gen.skip.contains(&func.name) {
+            if self.r#gen.skip.contains(&func.name) {
                 continue;
             }
-            let async_ = match &self.gen.opts.async_ {
+            let async_ = match &self.r#gen.opts.async_ {
                 AsyncConfig::None => false,
                 AsyncConfig::All => true,
                 AsyncConfig::Some { exports, .. } => {
@@ -1356,7 +1362,7 @@ pub mod vtable{ordinal} {{
             let style = if params_owned {
                 TypeOwnershipStyle::Owned
             } else {
-                match self.gen.opts.ownership {
+                match self.r#gen.opts.ownership {
                     Ownership::Owning => TypeOwnershipStyle::OnlyTopBorrowed,
                     Ownership::Borrowing { .. } => TypeOwnershipStyle::Borrowed,
                 }
@@ -1524,7 +1530,7 @@ pub mod vtable{ordinal} {{
             // The only possibility at that point is to borrow it at the root
             // but everything else internally is required to be owned from then
             // on.
-            match self.gen.opts.ownership {
+            match self.r#gen.opts.ownership {
                 Ownership::Owning => Some(lt),
                 Ownership::Borrowing { .. } => {
                     return TypeMode {
@@ -1648,7 +1654,7 @@ pub mod vtable{ordinal} {{
                 match mode.lifetime {
                     Some(lt) => self.print_borrowed_str(lt),
                     None => {
-                        if self.gen.opts.raw_strings {
+                        if self.r#gen.opts.raw_strings {
                             self.push_vec_name();
                             self.push_str("::<u8>");
                         } else {
@@ -1677,7 +1683,8 @@ pub mod vtable{ordinal} {{
 
     pub fn type_path(&self, id: TypeId, owned: bool) -> String {
         let full_wit_type_name = full_wit_type_name(self.resolve, id);
-        if let Some(TypeGeneration::Remap(remapped_path)) = self.gen.with.get(&full_wit_type_name) {
+        if let Some(TypeGeneration::Remap(remapped_path)) = self.r#gen.with.get(&full_wit_type_name)
+        {
             remapped_path.clone()
         } else {
             self.type_path_with_name(
@@ -1788,7 +1795,7 @@ pub mod vtable{ordinal} {{
     fn modes_of(&self, ty: TypeId) -> Vec<(String, TypeMode)> {
         let info = self.info(ty);
         let mut result = Vec::new();
-        if !self.gen.opts.generate_unused_types {
+        if !self.r#gen.opts.generate_unused_types {
             // If this type isn't actually used, no need to generate it.
             if !info.owned && !info.borrowed {
                 return result;
@@ -1808,7 +1815,7 @@ pub mod vtable{ordinal} {{
         } else if a == b {
             // If the modes are the same then there's only one result.
             result.push((self.result_name(ty), a));
-        } else if info.owned || matches!(self.gen.opts.ownership, Ownership::Owning) {
+        } else if info.owned || matches!(self.r#gen.opts.ownership, Ownership::Owning) {
             // If this type is owned or if ownership is preferred then the owned
             // variant is used as a priority. This is where the generator's
             // configuration comes into play.
@@ -1825,7 +1832,7 @@ pub mod vtable{ordinal} {{
         let info = self.info(id);
         // We use a BTree set to make sure we don't have any duplicates and we have a stable order
         let additional_derives: BTreeSet<String> = self
-            .gen
+            .r#gen
             .opts
             .additional_derive_attributes
             .iter()
@@ -1901,7 +1908,7 @@ pub mod vtable{ordinal} {{
                 self.push_str("write!(f, \"{:?}\", self)\n");
                 self.push_str("}\n");
                 self.push_str("}\n");
-                if self.gen.opts.std_feature {
+                if self.r#gen.opts.std_feature {
                     self.push_str("#[cfg(feature = \"std\")]\n");
                 }
                 self.push_str("impl std::error::Error for ");
@@ -1936,7 +1943,7 @@ pub mod vtable{ordinal} {{
         let info = self.info(id);
         // We use a BTree set to make sure we don't have any duplicates and have a stable order
         let additional_derives: BTreeSet<String> = self
-            .gen
+            .r#gen
             .opts
             .additional_derive_attributes
             .iter()
@@ -2003,7 +2010,7 @@ pub mod vtable{ordinal} {{
                 self.push_str("}\n");
                 self.push_str("\n");
 
-                if self.gen.opts.std_feature {
+                if self.r#gen.opts.std_feature {
                     self.push_str("#[cfg(feature = \"std\")]\n");
                 }
                 self.push_str("impl");
@@ -2102,7 +2109,7 @@ pub mod vtable{ordinal} {{
         // We use a BTree set to make sure we don't have any duplicates and a stable order
         let mut derives: BTreeSet<String> = BTreeSet::new();
         if !self
-            .gen
+            .r#gen
             .opts
             .additional_derive_ignore
             .contains(&name.to_kebab_case())
@@ -2187,7 +2194,7 @@ pub mod vtable{ordinal} {{
             self.push_str("}\n");
             self.push_str("}\n");
             self.push_str("\n");
-            if self.gen.opts.std_feature {
+            if self.r#gen.opts.std_feature {
                 self.push_str("#[cfg(feature = \"std\")]\n");
             }
             self.push_str("impl std::error::Error for ");
@@ -2250,7 +2257,7 @@ pub mod vtable{ordinal} {{
     fn uses_two_names(&self, info: &TypeInfo) -> bool {
         // Types are only duplicated if explicitly requested ...
         matches!(
-            self.gen.opts.ownership,
+            self.r#gen.opts.ownership,
             Ownership::Borrowing {
                 duplicate_if_necessary: true
             }
@@ -2266,7 +2273,7 @@ pub mod vtable{ordinal} {{
     }
 
     fn path_to_interface(&self, interface: InterfaceId) -> Option<String> {
-        let InterfaceName { path, remapped } = &self.gen.interface_names[&interface];
+        let InterfaceName { path, remapped } = &self.r#gen.interface_names[&interface];
         if *remapped {
             let mut path_to_root = self.path_to_root();
             path_to_root.push_str(path);
@@ -2319,7 +2326,7 @@ pub mod vtable{ordinal} {{
 
             // Interfaces are "stateful" currently where whatever we last saw
             // them as dictates whether it's exported or not.
-            TypeOwner::Interface(i) => !self.gen.interface_last_seen_as_import[&i],
+            TypeOwner::Interface(i) => !self.r#gen.interface_last_seen_as_import[&i],
 
             // Shouldn't be the case for resources
             TypeOwner::None => unreachable!(),
@@ -2336,7 +2343,7 @@ pub mod vtable{ordinal} {{
     }
 
     fn info(&self, ty: TypeId) -> TypeInfo {
-        self.gen.types.get(ty)
+        self.r#gen.types.get(ty)
     }
 
     fn print_borrowed_str(&mut self, lifetime: &'static str) {
@@ -2345,7 +2352,7 @@ pub mod vtable{ordinal} {{
             self.push_str(lifetime);
             self.push_str(" ");
         }
-        if self.gen.opts.raw_strings {
+        if self.r#gen.opts.raw_strings {
             self.push_str("[u8]");
         } else {
             self.push_str("str");
@@ -2425,7 +2432,7 @@ pub mod vtable{ordinal} {{
         name_in_runtime_module: &str,
     ) -> String {
         self.needs_runtime_module = true;
-        self.gen.rt_module.insert(item);
+        self.r#gen.rt_module.insert(item);
         let prefix = if let Identifier::StreamOrFuturePayload = &self.identifier {
             "super::super::"
         } else {
@@ -2661,7 +2668,7 @@ impl<'a> {camel}Borrow<'a>{{
     fn type_flags(&mut self, _id: TypeId, name: &str, flags: &Flags, docs: &Docs) {
         self.src.push_str(&format!(
             "{bitflags}::bitflags! {{\n",
-            bitflags = self.gen.bitflags_path()
+            bitflags = self.r#gen.bitflags_path()
         ));
         self.rustdoc(docs);
         let repr = RustFlagsRepr::new(flags);
@@ -2739,7 +2746,7 @@ impl<'a> {camel}Borrow<'a>{{
     }
 
     fn type_future(&mut self, _id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs) {
-        let async_support = self.gen.async_support_path();
+        let async_support = self.r#gen.async_support_path();
         let mode = TypeMode {
             style: TypeOwnershipStyle::Owned,
             lists_borrowed: false,
@@ -2756,7 +2763,7 @@ impl<'a> {camel}Borrow<'a>{{
     }
 
     fn type_stream(&mut self, _id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs) {
-        let async_support = self.gen.async_support_path();
+        let async_support = self.r#gen.async_support_path();
         let mode = TypeMode {
             style: TypeOwnershipStyle::Owned,
             lists_borrowed: false,
@@ -2861,7 +2868,7 @@ impl<'a, 'b> wit_bindgen_core::AnonymousTypeGenerator<'a> for AnonTypeGenerator<
     }
 
     fn anonymous_type_future(&mut self, _id: TypeId, ty: &Option<Type>, _docs: &Docs) {
-        let async_support = self.interface.gen.async_support_path();
+        let async_support = self.interface.r#gen.async_support_path();
         let mode = TypeMode {
             style: TypeOwnershipStyle::Owned,
             lists_borrowed: false,
@@ -2874,7 +2881,7 @@ impl<'a, 'b> wit_bindgen_core::AnonymousTypeGenerator<'a> for AnonTypeGenerator<
     }
 
     fn anonymous_type_stream(&mut self, _id: TypeId, ty: &Option<Type>, _docs: &Docs) {
-        let async_support = self.interface.gen.async_support_path();
+        let async_support = self.interface.r#gen.async_support_path();
         let mode = TypeMode {
             style: TypeOwnershipStyle::Owned,
             lists_borrowed: false,
diff --git a/crates/rust/src/lib.rs b/crates/rust/src/lib.rs
index f72f76f83..cfaebda24 100644
--- a/crates/rust/src/lib.rs
+++ b/crates/rust/src/lib.rs
@@ -347,7 +347,7 @@ impl RustWasm {
             wasm_import_module,
             src: Source::default(),
             in_import,
-            gen: self,
+            r#gen: self,
             sizes,
             resolve,
             return_pointer_area_size: Default::default(),
@@ -1128,26 +1128,26 @@ impl WorldGenerator for RustWasm {
 
         self.interface_last_seen_as_import.insert(id, true);
         let wasm_import_module = resolve.name_world_key(name);
-        let mut gen = self.interface(
+        let mut r#gen = self.interface(
             Identifier::Interface(id, name),
             &wasm_import_module,
             resolve,
             true,
         );
-        let (snake, module_path) = gen.start_append_submodule(name);
-        if gen.gen.name_interface(resolve, id, name, false)? {
+        let (snake, module_path) = r#gen.start_append_submodule(name);
+        if r#gen.r#gen.name_interface(resolve, id, name, false)? {
             return Ok(());
         }
 
         for (name, ty_id) in to_define {
-            gen.define_type(&name, *ty_id);
+            r#gen.define_type(&name, *ty_id);
         }
 
-        gen.generate_imports(resolve.interfaces[id].functions.values(), Some(name));
+        r#gen.generate_imports(resolve.interfaces[id].functions.values(), Some(name));
 
         let docs = &resolve.interfaces[id].docs;
 
-        gen.finish_append_submodule(&snake, module_path, docs);
+        r#gen.finish_append_submodule(&snake, module_path, docs);
 
         Ok(())
     }
@@ -1161,11 +1161,11 @@ impl WorldGenerator for RustWasm {
     ) {
         self.import_funcs_called = true;
 
-        let mut gen = self.interface(Identifier::World(world), "$root", resolve, true);
+        let mut r#gen = self.interface(Identifier::World(world), "$root", resolve, true);
 
-        gen.generate_imports(funcs.iter().map(|(_, func)| *func), None);
+        r#gen.generate_imports(funcs.iter().map(|(_, func)| *func), None);
 
-        let src = gen.finish();
+        let src = r#gen.finish();
         self.src.push_str(&src);
     }
 
@@ -1192,40 +1192,40 @@ impl WorldGenerator for RustWasm {
 
         self.interface_last_seen_as_import.insert(id, false);
         let wasm_import_module = format!("[export]{}", resolve.name_world_key(name));
-        let mut gen = self.interface(
+        let mut r#gen = self.interface(
             Identifier::Interface(id, name),
             &wasm_import_module,
             resolve,
             false,
         );
-        let (snake, module_path) = gen.start_append_submodule(name);
-        if gen.gen.name_interface(resolve, id, name, true)? {
+        let (snake, module_path) = r#gen.start_append_submodule(name);
+        if r#gen.r#gen.name_interface(resolve, id, name, true)? {
             return Ok(());
         }
 
         for (name, ty_id) in to_define {
-            gen.define_type(&name, *ty_id);
+            r#gen.define_type(&name, *ty_id);
         }
 
         let macro_name =
-            gen.generate_exports(Some((id, name)), resolve.interfaces[id].functions.values())?;
+            r#gen.generate_exports(Some((id, name)), resolve.interfaces[id].functions.values())?;
 
         let docs = &resolve.interfaces[id].docs;
 
-        gen.finish_append_submodule(&snake, module_path, docs);
+        r#gen.finish_append_submodule(&snake, module_path, docs);
         self.export_macros
             .push((macro_name, self.interface_names[&id].path.clone()));
 
         if self.opts.stubs {
             let world_id = self.world.unwrap();
-            let mut gen = self.interface(
+            let mut r#gen = self.interface(
                 Identifier::World(world_id),
                 &wasm_import_module,
                 resolve,
                 false,
             );
-            gen.generate_stub(Some((id, name)), resolve.interfaces[id].functions.values());
-            let stub = gen.finish();
+            r#gen.generate_stub(Some((id, name)), resolve.interfaces[id].functions.values());
+            let stub = r#gen.finish();
             self.src.push_str(&stub);
         }
         Ok(())
@@ -1238,16 +1238,17 @@ impl WorldGenerator for RustWasm {
         funcs: &[(&str, &Function)],
         _files: &mut Files,
     ) -> Result<()> {
-        let mut gen = self.interface(Identifier::World(world), "[export]$root", resolve, false);
-        let macro_name = gen.generate_exports(None, funcs.iter().map(|f| f.1))?;
-        let src = gen.finish();
+        let mut r#gen = self.interface(Identifier::World(world), "[export]$root", resolve, false);
+        let macro_name = r#gen.generate_exports(None, funcs.iter().map(|f| f.1))?;
+        let src = r#gen.finish();
         self.src.push_str(&src);
         self.export_macros.push((macro_name, String::new()));
 
         if self.opts.stubs {
-            let mut gen = self.interface(Identifier::World(world), "[export]$root", resolve, false);
-            gen.generate_stub(None, funcs.iter().map(|f| f.1));
-            let stub = gen.finish();
+            let mut r#gen =
+                self.interface(Identifier::World(world), "[export]$root", resolve, false);
+            r#gen.generate_stub(None, funcs.iter().map(|f| f.1));
+            let stub = r#gen.finish();
             self.src.push_str(&stub);
         }
         Ok(())
@@ -1273,11 +1274,11 @@ impl WorldGenerator for RustWasm {
             }
             self.generated_types.insert(full_name);
         }
-        let mut gen = self.interface(Identifier::World(world), "$root", resolve, true);
+        let mut r#gen = self.interface(Identifier::World(world), "$root", resolve, true);
         for (name, ty) in to_define {
-            gen.define_type(name, *ty);
+            r#gen.define_type(name, *ty);
         }
-        let src = gen.finish();
+        let src = r#gen.finish();
         self.src.push_str(&src);
     }
 
diff --git a/crates/test-rust-wasm/rust-xcrate-test/Cargo.toml b/crates/test-rust-wasm/rust-xcrate-test/Cargo.toml
index 148687db5..0e3825024 100644
--- a/crates/test-rust-wasm/rust-xcrate-test/Cargo.toml
+++ b/crates/test-rust-wasm/rust-xcrate-test/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rust-xcrate-test"
-edition.workspace = true
+edition = "2024"
 publish = false
 
 [dependencies]