Allow unused fields in Instructions

Author: daxpedda

crates/cli-support/src/js/binding.rs

@@ -1240,6 +1240,7 @@ fn instruction(
 
         Instruction::CachedStringLoad {
             owned,
+            optional: _,
             mem,
             free,
             table,

crates/cli-support/src/js/mod.rs

@@ -3274,6 +3274,7 @@ __wbg_set_wasm(wasm);"
                 dtor,
                 mutable,
                 adapter,
+                nargs: _,
             } => {
                 assert!(kind == AdapterJsImportKind::Normal);
                 assert!(!variadic);

crates/cli-support/src/wit/incoming.rs

@@ -117,6 +117,7 @@ impl InstructionBuilder<'_, '_> {
                     &[AdapterType::Enum(name.clone())],
                     Instruction::IntToWasm {
                         input: AdapterType::U32,
+                        output: ValType::I32,
                     },
                     &[AdapterType::I32],
                 );
@@ -472,6 +473,7 @@ impl InstructionBuilder<'_, '_> {
     fn number(&mut self, input: AdapterType, output: walrus::ValType) {
         let instr = Instruction::IntToWasm {
             input: input.clone(),
+            output,
         };
         self.instruction(&[input], instr, &[AdapterType::from_wasm(output).unwrap()]);
     }

crates/cli-support/src/wit/mod.rs

@@ -197,6 +197,7 @@ impl<'a> Context<'a> {
                 // aren't present in the signature but are present in the wasm
                 // signature.
                 let mut function = descriptor.function.clone();
+                let nargs = function.arguments.len();
                 function.arguments.insert(0, Descriptor::I32);
                 function.arguments.insert(0, Descriptor::I32);
                 let adapter = self.table_element_adapter(descriptor.shim_idx, function)?;
@@ -205,6 +206,7 @@ impl<'a> Context<'a> {
                     AuxImport::Closure {
                         dtor: descriptor.dtor_idx,
                         mutable: descriptor.mutable,
+                        nargs,
                         adapter,
                     },
                 );
@@ -1202,7 +1204,7 @@ impl<'a> Context<'a> {
         kind: AdapterJsImportKind,
     ) -> Result<AdapterId, Error> {
         let import = self.module.imports.get(import);
-        let import_name = import.name.clone();
+        let (import_module, import_name) = (import.module.clone(), import.name.clone());
         let import_id = import.id();
         let core_id = match import.kind {
             walrus::ImportKind::Function(f) => f,
@@ -1239,6 +1241,7 @@ impl<'a> Context<'a> {
             ret.input,
             vec![],
             AdapterKind::Import {
+                module: import_module,
                 name: import_name,
                 kind,
             },

crates/cli-support/src/wit/nonstandard.rs

@@ -244,6 +244,8 @@ pub enum AuxImport {
         mutable: bool,      // whether or not this was a `FnMut` closure
         dtor: u32,          // table element index of the destructor function
         adapter: AdapterId, // the adapter which translates the types for this closure
+        #[allow(dead_code)]
+        nargs: usize,
     },
 
     /// This import is expected to be a shim that simply calls the `foo` method

crates/cli-support/src/wit/outgoing.rs

@@ -110,7 +110,7 @@ impl InstructionBuilder<'_, '_> {
             Descriptor::Ref(d) => self.outgoing_ref(false, d)?,
             Descriptor::RefMut(d) => self.outgoing_ref(true, d)?,
 
-            Descriptor::CachedString => self.cached_string(false)?,
+            Descriptor::CachedString => self.cached_string(false, true)?,
 
             Descriptor::String => {
                 // fetch the ptr/length ...
@@ -193,7 +193,7 @@ impl InstructionBuilder<'_, '_> {
                     &[AdapterType::NamedExternref(name.clone())],
                 );
             }
-            Descriptor::CachedString => self.cached_string(false)?,
+            Descriptor::CachedString => self.cached_string(false, false)?,
 
             Descriptor::String => {
                 self.instruction(
@@ -316,10 +316,13 @@ impl InstructionBuilder<'_, '_> {
                     &[AdapterType::Enum(name.clone()).option()],
                 );
             }
-            Descriptor::StringEnum { name, .. } => {
+            Descriptor::StringEnum { name, hole, .. } => {
                 self.instruction(
                     &[AdapterType::I32],
-                    Instruction::OptionWasmToStringEnum { name: name.clone() },
+                    Instruction::OptionWasmToStringEnum {
+                        name: name.clone(),
+                        hole: *hole,
+                    },
                     &[AdapterType::StringEnum(name.clone()).option()],
                 );
             }
@@ -335,7 +338,7 @@ impl InstructionBuilder<'_, '_> {
             Descriptor::Ref(d) => self.outgoing_option_ref(false, d)?,
             Descriptor::RefMut(d) => self.outgoing_option_ref(true, d)?,
 
-            Descriptor::CachedString => self.cached_string(true)?,
+            Descriptor::CachedString => self.cached_string(true, true)?,
 
             Descriptor::String | Descriptor::Vector(_) => {
                 let kind = arg.vector_kind().ok_or_else(|| {
@@ -525,7 +528,7 @@ impl InstructionBuilder<'_, '_> {
                     &[AdapterType::NamedExternref(name.clone()).option()],
                 );
             }
-            Descriptor::CachedString => self.cached_string(true)?,
+            Descriptor::CachedString => self.cached_string(true, false)?,
             Descriptor::String | Descriptor::Slice(_) => {
                 let kind = arg.vector_kind().ok_or_else(|| {
                     format_err!(
@@ -553,6 +556,7 @@ impl InstructionBuilder<'_, '_> {
 
     fn outgoing_i32(&mut self, output: AdapterType) {
         let instr = Instruction::WasmToInt {
+            input: walrus::ValType::I32,
             output: output.clone(),
         };
         self.instruction(&[AdapterType::I32], instr, &[output]);
@@ -570,18 +574,20 @@ impl InstructionBuilder<'_, '_> {
 
     fn outgoing_i64(&mut self, output: AdapterType) {
         let instr = Instruction::WasmToInt {
+            input: walrus::ValType::I64,
             output: output.clone(),
         };
         self.instruction(&[AdapterType::I64], instr, &[output]);
     }
 
-    fn cached_string(&mut self, owned: bool) -> Result<(), Error> {
+    fn cached_string(&mut self, optional: bool, owned: bool) -> Result<(), Error> {
         let mem = self.cx.memory()?;
         let free = self.cx.free()?;
         self.instruction(
             &[AdapterType::I32, AdapterType::I32],
             Instruction::CachedStringLoad {
                 owned,
+                optional,
                 mem,
                 free,
                 table: None,

crates/cli-support/src/wit/standard.rs

@@ -40,6 +40,8 @@ pub enum AdapterKind {
         instructions: Vec<InstructionData>,
     },
     Import {
+        #[allow(dead_code)]
+        module: String,
         name: String,
         kind: AdapterJsImportKind,
     },
@@ -138,9 +140,13 @@ pub enum Instruction {
     /// Pops a typed integer (`u8`, `s16`, etc.) and pushes a plain Wasm `i32` or `i64` equivalent.
     IntToWasm {
         input: AdapterType,
+        #[allow(dead_code)]
+        output: walrus::ValType,
     },
     /// Pops a Wasm `i32` or `i64` and pushes a typed integer (`u8`, `s16`, etc.) equivalent.
     WasmToInt {
+        #[allow(dead_code)]
+        input: walrus::ValType,
         output: AdapterType,
     },
 
@@ -163,6 +169,8 @@ pub enum Instruction {
 
     OptionWasmToStringEnum {
         name: String,
+        #[allow(dead_code)]
+        hole: u32,
     },
 
     /// pops a string and pushes the enum variant as an `i32`
@@ -306,6 +314,8 @@ pub enum Instruction {
     /// pops ptr/length i32, loads string from cache
     CachedStringLoad {
         owned: bool,
+        #[allow(dead_code)]
+        optional: bool,
         mem: walrus::MemoryId,
         free: walrus::FunctionId,
         /// If we're in reference-types mode, the externref table ID to get the cached string from.