Add convenience methods to instance for getting specific extern types.

Author: sunfishcode

crates/api/src/externals.rs

@@ -702,7 +702,7 @@ impl Memory {
     /// let store = Store::default();
     /// let module = Module::new(&store, "(module (memory (export \"mem\") 1))")?;
     /// let instance = Instance::new(&module, &[])?;
-    /// let memory = instance.get_export("mem").unwrap().into_memory().unwrap();
+    /// let memory = instance.get_memory("mem").unwrap();
     /// let ty = memory.ty();
     /// assert_eq!(ty.limits().min(), 1);
     /// # Ok(())

crates/api/src/instance.rs

@@ -1,4 +1,5 @@
-use crate::externals::{Export, Extern};
+use crate::externals::{Export, Extern, Global, Memory, Table};
+use crate::func::Func;
 use crate::module::Module;
 use crate::runtime::{Config, Store};
 use crate::trap::Trap;
@@ -188,6 +189,38 @@ impl Instance {
         ))
     }
 
+    /// Looks up an exported [`Func`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a function.
+    pub fn get_func(&self, name: &str) -> Option<Func> {
+        self.get_export(name)?.into_func()
+    }
+
+    /// Looks up an exported [`Table`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a table.
+    pub fn get_table(&self, name: &str) -> Option<Table> {
+        self.get_export(name)?.into_table()
+    }
+
+    /// Looks up an exported [`Memory`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a memory.
+    pub fn get_memory(&self, name: &str) -> Option<Memory> {
+        self.get_export(name)?.into_memory()
+    }
+
+    /// Looks up an exported [`Global`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a global.
+    pub fn get_global(&self, name: &str) -> Option<Global> {
+        self.get_export(name)?.into_global()
+    }
+
     #[doc(hidden)]
     pub fn handle(&self) -> &InstanceHandle {
         &self.instance_handle

crates/fuzzing/src/oracles.rs

@@ -185,13 +185,11 @@ pub fn differential_execution(
             // infinite loop when calling another export.
             init_hang_limit(&instance);
 
-            let f = match instance
+            let f = instance
                 .get_export(&name)
                 .expect("instance should have export from module")
-            {
-                Extern::Func(f) => f.clone(),
-                _ => panic!("export should be a function"),
-            };
+                .into_func()
+                .expect("export should be a function");
 
             let ty = f.ty();
             let params = match dummy::dummy_values(ty.params()) {

crates/test-programs/tests/wasm_tests/runtime.rs

@@ -52,15 +52,11 @@ pub fn instantiate(
     let imports = module
         .imports()
         .map(|i| {
-            let field_name = i.name();
-            if let Some(export) = snapshot1.get_export(field_name) {
+            let field_name = i.name;
+            if let Some(export) = snapshot1.get_export(&field_name) {
                 Ok(export.clone().into())
             } else {
-                bail!(
-                    "import {} was not found in module {}",
-                    field_name,
-                    i.module(),
-                )
+                bail!("import {} was not found in module {}", field_name, i.module,)
             }
         })
         .collect::<Result<Vec<_>, _>>()?;
@@ -70,13 +66,10 @@ pub fn instantiate(
         bin_name,
     ))?;
 
-    let export = instance
+    instance
         .get_export("_start")
         .context("expected a _start export")?
-        .clone();
-
-    export
-        .func()
+        .into_func()
         .context("expected export to be a func")?
         .call(&[])?;
 

docs/wasm-wat.md

@@ -47,7 +47,7 @@ let wat = r#"
 "#;
 let module = Module::new(&store, wat)?;
 let instance = Instance::new(&module, &[])?;
-let add = instance.get_export("add").and_then(|f| f.into_func()).unwrap();
+let add = instance.get_func("add").unwrap();
 let add = add.get2::<i32, i32, i32>()?;
 println!("1 + 2 = {}", add(1, 2)?);
 # Ok(())

examples/fib-debug/main.rs

@@ -22,8 +22,7 @@ fn main() -> Result<()> {
 
     // Invoke `fib` export
     let fib = instance
-        .get_export("fib")
-        .and_then(|e| e.into_func())
+        .get_func("fib")
         .ok_or(anyhow::format_err!("failed to find `fib` function export"))?
         .get1::<i32, i32>()?;
     println!("fib(6) = {}", fib(6)?);

examples/gcd.rs

@@ -16,8 +16,7 @@ fn main() -> Result<()> {
 
     // Invoke `gcd` export
     let gcd = instance
-        .get_export("gcd")
-        .and_then(|e| e.into_func())
+        .get_func("gcd")
         .ok_or(anyhow::format_err!("failed to find `gcd` function export"))?
         .get2::<i32, i32, i32>()?;
 

examples/hello.rs

@@ -35,8 +35,7 @@ fn main() -> Result<()> {
     // Next we poke around a bit to extract the `run` function from the module.
     println!("Extracting export...");
     let run = instance
-        .get_export("run")
-        .and_then(|e| e.into_func())
+        .get_func("run")
         .ok_or(anyhow::format_err!("failed to find `run` function export"))?
         .get0::<()>()?;
 

examples/linking.rs

@@ -26,10 +26,7 @@ fn main() -> Result<()> {
 
     // And with that we can perform the final link and the execute the module.
     let linking1 = linker.instantiate(&linking1)?;
-    let run = linking1
-        .get_export("run")
-        .and_then(|e| e.into_func())
-        .unwrap();
+    let run = linking1.get_func("run").unwrap();
     let run = run.get0::<()>()?;
     run()?;
     Ok(())

examples/memory.rs

@@ -18,22 +18,18 @@ fn main() -> Result<()> {
 
     // Load up our exports from the instance
     let memory = instance
-        .get_export("memory")
-        .and_then(|e| e.into_memory())
+        .get_memory("memory")
         .ok_or(anyhow::format_err!("failed to find `memory` export"))?;
     let size = instance
-        .get_export("size")
-        .and_then(|e| e.into_func())
+        .get_func("size")
         .ok_or(anyhow::format_err!("failed to find `size` export"))?
         .get0::<i32>()?;
     let load = instance
-        .get_export("load")
-        .and_then(|e| e.into_func())
+        .get_func("load")
         .ok_or(anyhow::format_err!("failed to find `load` export"))?
         .get1::<i32, i32>()?;
     let store = instance
-        .get_export("store")
-        .and_then(|e| e.into_func())
+        .get_func("store")
         .ok_or(anyhow::format_err!("failed to find `store` export"))?
         .get2::<i32, i32, ()>()?;