Implement RFC 11: Redesigning Wasmtime's APIs (#2897)

Implement Wasmtime's new API as designed by RFC 11. This is quite a large commit which has had lots of discussion externally, so for more information it's best to read the RFC thread and the PR thread.

tests/all/globals.rs

@@ -2,56 +2,56 @@ use wasmtime::*;
 
 #[test]
 fn smoke() -> anyhow::Result<()> {
-    let store = Store::default();
+    let mut store = Store::<()>::default();
     let g = Global::new(
-        &store,
+        &mut store,
         GlobalType::new(ValType::I32, Mutability::Const),
         0.into(),
     )?;
-    assert_eq!(g.get().i32(), Some(0));
-    assert!(g.set(0.into()).is_err());
+    assert_eq!(g.get(&mut store).i32(), Some(0));
+    assert!(g.set(&mut store, 0.into()).is_err());
 
     let g = Global::new(
-        &store,
+        &mut store,
         GlobalType::new(ValType::I32, Mutability::Const),
         1i32.into(),
     )?;
-    assert_eq!(g.get().i32(), Some(1));
+    assert_eq!(g.get(&mut store).i32(), Some(1));
 
     let g = Global::new(
-        &store,
+        &mut store,
         GlobalType::new(ValType::I64, Mutability::Const),
         2i64.into(),
     )?;
-    assert_eq!(g.get().i64(), Some(2));
+    assert_eq!(g.get(&mut store).i64(), Some(2));
 
     let g = Global::new(
-        &store,
+        &mut store,
         GlobalType::new(ValType::F32, Mutability::Const),
         3.0f32.into(),
     )?;
-    assert_eq!(g.get().f32(), Some(3.0));
+    assert_eq!(g.get(&mut store).f32(), Some(3.0));
 
     let g = Global::new(
-        &store,
+        &mut store,
         GlobalType::new(ValType::F64, Mutability::Const),
         4.0f64.into(),
     )?;
-    assert_eq!(g.get().f64(), Some(4.0));
+    assert_eq!(g.get(&mut store).f64(), Some(4.0));
     Ok(())
 }
 
 #[test]
 fn mutability() -> anyhow::Result<()> {
-    let store = Store::default();
+    let mut store = Store::<()>::default();
     let g = Global::new(
-        &store,
+        &mut store,
         GlobalType::new(ValType::I32, Mutability::Var),
         0.into(),
     )?;
-    assert_eq!(g.get().i32(), Some(0));
-    g.set(1.into())?;
-    assert_eq!(g.get().i32(), Some(1));
+    assert_eq!(g.get(&mut store).i32(), Some(0));
+    g.set(&mut store, 1.into())?;
+    assert_eq!(g.get(&mut store).i32(), Some(1));
     Ok(())
 }
 
@@ -61,7 +61,7 @@ fn mutability() -> anyhow::Result<()> {
 // least some cases of heap corruption.
 #[test]
 fn use_after_drop() -> anyhow::Result<()> {
-    let store = Store::default();
+    let mut store = Store::<()>::default();
     let module = Module::new(
         store.engine(),
         r#"
@@ -69,18 +69,16 @@ fn use_after_drop() -> anyhow::Result<()> {
                 (global (export "foo") (mut i32) (i32.const 100)))
         "#,
     )?;
-    let instance = Instance::new(&store, &module, &[])?;
-    let g = instance.get_global("foo").unwrap();
-    assert_eq!(g.get().i32(), Some(100));
-    g.set(101.into())?;
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let g = instance.get_global(&mut store, "foo").unwrap();
+    assert_eq!(g.get(&mut store).i32(), Some(100));
+    g.set(&mut store, 101.into())?;
     drop(instance);
-    assert_eq!(g.get().i32(), Some(101));
-    Instance::new(&store, &module, &[])?;
-    assert_eq!(g.get().i32(), Some(101));
+    assert_eq!(g.get(&mut store).i32(), Some(101));
+    Instance::new(&mut store, &module, &[])?;
+    assert_eq!(g.get(&mut store).i32(), Some(101));
     drop(module);
-    assert_eq!(g.get().i32(), Some(101));
-    drop(store);
-    assert_eq!(g.get().i32(), Some(101));
+    assert_eq!(g.get(&mut store).i32(), Some(101));
 
     // spray some heap values
     let mut x = Vec::new();
@@ -88,6 +86,6 @@ fn use_after_drop() -> anyhow::Result<()> {
         x.push("xy".to_string());
     }
     drop(x);
-    assert_eq!(g.get().i32(), Some(101));
+    assert_eq!(g.get(&mut store).i32(), Some(101));
     Ok(())
 }