Don't require Store in Instance constructor (#810)

* Don't require `Store` in `Instance` constructor

This can be inferred from the `Module` argument. Additionally add a
`store` accessor to an `Instance` in case it's needed to instantiate
another `Module`.

cc #708

* Update more constructors

* Fix a doctest

* Don't ignore store in `wasm_instance_new`

* Run rustfmt

crates/api/examples/gcd.rs

@@ -50,7 +50,7 @@ fn main() -> anyhow::Result<()> {
         .0;
 
     // Instantiate the module.
-    let instance = Instance::new(&store, &module, &[])?;
+    let instance = Instance::new(&module, &[])?;
 
     // Invoke `gcd` export
     let gcd = instance.exports()[gcd_index].func().expect("gcd");

crates/api/examples/hello.rs

@@ -48,8 +48,7 @@ fn main() -> Result<()> {
     // Note that this is where the wasm `start` function, if any, would run.
     println!("Instantiating module...");
     let imports = vec![hello_func.into()];
-    let instance =
-        Instance::new(&store, &module, &imports).context("> Error instantiating module!")?;
+    let instance = Instance::new(&module, &imports).context("> Error instantiating module!")?;
 
     // Next we poke around a bit to extract the `run` function from the module.
     println!("Extracting export...");

crates/api/examples/memory.rs

@@ -90,7 +90,7 @@ fn main() -> Result<(), Error> {
 
     // Instantiate.
     println!("Instantiating module...");
-    let instance = Instance::new(&store, &module, &[]).context("> Error instantiating module!")?;
+    let instance = Instance::new(&module, &[]).context("> Error instantiating module!")?;
 
     // Extract export.
     println!("Extracting export...");

crates/api/examples/multi.rs

@@ -67,8 +67,8 @@ fn main() -> Result<()> {
     // Instantiate.
     println!("Instantiating module...");
     let imports = vec![callback_func.into()];
-    let instance = Instance::new(&store, &module, imports.as_slice())
-        .context("Error instantiating module!")?;
+    let instance =
+        Instance::new(&module, imports.as_slice()).context("Error instantiating module!")?;
 
     // Extract exports.
     println!("Extracting export...");

crates/api/src/callable.rs

@@ -59,7 +59,6 @@ use wasmtime_runtime::Export;
 ///
 /// // Create module instance that imports our function
 /// let instance = wasmtime::Instance::new(
-///     &store,
 ///     &module,
 ///     &[times_two_function.into()]
 /// )?;

crates/api/src/instance.rs

@@ -68,7 +68,8 @@ pub struct Instance {
 }
 
 impl Instance {
-    pub fn new(store: &Store, module: &Module, externs: &[Extern]) -> Result<Instance, Error> {
+    pub fn new(module: &Module, externs: &[Extern]) -> Result<Instance, Error> {
+        let store = module.store();
         let context = store.context().clone();
         let exports = store.global_exports().clone();
         let (mut instance_handle, contexts) = instantiate_in_context(
@@ -100,14 +101,27 @@ impl Instance {
         })
     }
 
-    pub fn exports(&self) -> &[Extern] {
-        &self.exports
+    /// Returns the associated [`Store`] that this `Instance` is compiled into.
+    ///
+    /// This is the [`Store`] that generally serves as a sort of global cache
+    /// for various instance-related things.
+    pub fn store(&self) -> &Store {
+        self.module.store()
     }
 
+    /// Returns the associated [`Module`] that this `Instance` instantiated.
+    ///
+    /// The corresponding [`Module`] here is a static version of this `Instance`
+    /// which can be used to learn information such as naming information about
+    /// various functions.
     pub fn module(&self) -> &Module {
         &self.module
     }
 
+    pub fn exports(&self) -> &[Extern] {
+        &self.exports
+    }
+
     pub fn find_export_by_name(&self, name: &str) -> Option<&Extern> {
         let (i, _) = self
             .module

crates/api/src/runtime.rs

@@ -397,6 +397,10 @@ impl Store {
             .get(&type_index)
             .cloned()
     }
+
+    pub(crate) fn ptr_eq(a: &Store, b: &Store) -> bool {
+        Rc::ptr_eq(&a.inner, &b.inner)
+    }
 }
 
 impl Default for Store {

crates/api/src/wasm.rs

@@ -686,7 +686,6 @@ pub unsafe extern "C" fn wasm_instance_new(
     imports: *const *const wasm_extern_t,
     result: *mut *mut wasm_trap_t,
 ) -> *mut wasm_instance_t {
-    let store = &(*store).store.borrow();
     let mut externs: Vec<Extern> = Vec::with_capacity((*module).imports.len());
     for i in 0..(*module).imports.len() {
         let import = *imports.add(i);
@@ -697,8 +696,21 @@ pub unsafe extern "C" fn wasm_instance_new(
             ExternHost::Memory(e) => Extern::Memory(e.borrow().clone()),
         });
     }
+    let store = &(*store).store.borrow();
     let module = &(*module).module.borrow();
-    match Instance::new(store, module, &externs) {
+    // FIXME(WebAssembly/wasm-c-api#126) what else can we do with the `store`
+    // argument?
+    if !Store::ptr_eq(&store, module.store()) {
+        if !result.is_null() {
+            let trap = Trap::new("wasm_store_t must match store in wasm_module_t");
+            let trap = Box::new(wasm_trap_t {
+                trap: HostRef::new(trap),
+            });
+            (*result) = Box::into_raw(trap);
+        }
+        return ptr::null_mut();
+    }
+    match Instance::new(module, &externs) {
         Ok(instance) => {
             let instance = Box::new(wasm_instance_t {
                 instance: HostRef::new(instance),

crates/api/tests/import-indexes.rs

@@ -55,7 +55,7 @@ fn same_import_names_still_distinct() -> anyhow::Result<()> {
         )
         .into(),
     ];
-    let instance = Instance::new(&store, &module, &imports)?;
+    let instance = Instance::new(&module, &imports)?;
 
     let func = instance.find_export_by_name("foo").unwrap().func().unwrap();
     let results = func.call(&[])?;

crates/api/tests/import_calling_export.rs

@@ -47,7 +47,7 @@ fn test_import_calling_export() {
 
     let imports = vec![callback_func.into()];
     let instance =
-        Instance::new(&store, &module, imports.as_slice()).expect("failed to instantiate module");
+        Instance::new(&module, imports.as_slice()).expect("failed to instantiate module");
 
     let exports = instance.exports();
     assert!(!exports.is_empty());

crates/api/tests/traps.rs

@@ -29,7 +29,7 @@ fn test_trap_return() -> Result<(), String> {
     let hello_func = Func::new(&store, hello_type, Rc::new(HelloCallback));
 
     let imports = vec![hello_func.into()];
-    let instance = Instance::new(&store, &module, &imports)
+    let instance = Instance::new(&module, &imports)
         .map_err(|e| format!("failed to instantiate module: {:?}", e))?;
     let run_func = instance.exports()[0]
         .func()