From 3fb46b6aa822fae191e5c40150a90e0cadefe88e Mon Sep 17 00:00:00 2001
From: ptitSeb <sebastien.chev@gmail.com>
Date: Wed, 29 Jun 2022 09:42:56 +0200
Subject: [PATCH] Removed some useless as_context_mut()

---
 tests/compilers/imports.rs          | 76 ++++++++++++------------
 tests/compilers/issues.rs           | 18 +++---
 tests/compilers/metering.rs         | 14 ++---
 tests/compilers/middlewares.rs      | 30 +++++-----
 tests/compilers/native_functions.rs | 90 ++++++++++++++---------------
 tests/compilers/serialize.rs        |  4 +-
 tests/compilers/traps.rs            | 54 ++++++++---------
 7 files changed, 143 insertions(+), 143 deletions(-)

diff --git a/tests/compilers/imports.rs b/tests/compilers/imports.rs
index 28283a35dd9..f2fa3e215ac 100644
--- a/tests/compilers/imports.rs
+++ b/tests/compilers/imports.rs
@@ -106,7 +106,7 @@ fn dynamic_function_with_env(config: crate::Config) -> Result<()> {
     };
     let mut ctx = WasmerContext::new(&store, env);
     let f0 = Function::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         FunctionType::new(vec![], vec![]),
         |ctx, _values| {
             assert_eq!(ctx.data().fetch_add(1, SeqCst), 0);
@@ -114,7 +114,7 @@ fn dynamic_function_with_env(config: crate::Config) -> Result<()> {
         },
     );
     let f1 = Function::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         FunctionType::new(vec![ValueType::I32], vec![ValueType::I32]),
         |ctx, values| {
             assert_eq!(values[0], Value::I32(0));
@@ -123,7 +123,7 @@ fn dynamic_function_with_env(config: crate::Config) -> Result<()> {
         },
     );
     let f2 = Function::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         FunctionType::new(vec![ValueType::I32, ValueType::I64], vec![]),
         |ctx, values| {
             assert_eq!(values[0], Value::I32(2));
@@ -133,7 +133,7 @@ fn dynamic_function_with_env(config: crate::Config) -> Result<()> {
         },
     );
     let f3 = Function::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         FunctionType::new(
             vec![
                 ValueType::I32,
@@ -155,7 +155,7 @@ fn dynamic_function_with_env(config: crate::Config) -> Result<()> {
         },
     );
     Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "host" => {
@@ -178,11 +178,11 @@ fn static_function(config: crate::Config) -> Result<()> {
 
     static HITS: AtomicUsize = AtomicUsize::new(0);
     let mut ctx = WasmerContext::new(&store, ());
-    let f0 = Function::new_native(&mut ctx.as_context_mut(), |_ctx: ContextMut<_>| {
+    let f0 = Function::new_native(&mut ctx, |_ctx: ContextMut<_>| {
         assert_eq!(HITS.fetch_add(1, SeqCst), 0);
     });
     let f1 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |_ctx: ContextMut<_>, x: i32| -> i32 {
             assert_eq!(x, 0);
             assert_eq!(HITS.fetch_add(1, SeqCst), 1);
@@ -190,7 +190,7 @@ fn static_function(config: crate::Config) -> Result<()> {
         },
     );
     let f2 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |_ctx: ContextMut<_>, x: i32, y: i64| {
             assert_eq!(x, 2);
             assert_eq!(y, 3);
@@ -198,7 +198,7 @@ fn static_function(config: crate::Config) -> Result<()> {
         },
     );
     let f3 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |_ctx: ContextMut<_>, a: i32, b: i64, c: i32, d: f32, e: f64| {
             assert_eq!(a, 100);
             assert_eq!(b, 200);
@@ -209,7 +209,7 @@ fn static_function(config: crate::Config) -> Result<()> {
         },
     );
     Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "host" => {
@@ -232,11 +232,11 @@ fn static_function_with_results(config: crate::Config) -> Result<()> {
 
     static HITS: AtomicUsize = AtomicUsize::new(0);
     let mut ctx = WasmerContext::new(&store, ());
-    let f0 = Function::new_native(&mut ctx.as_context_mut(), |_ctx: ContextMut<_>| {
+    let f0 = Function::new_native(&mut ctx, |_ctx: ContextMut<_>| {
         assert_eq!(HITS.fetch_add(1, SeqCst), 0);
     });
     let f1 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |_ctx: ContextMut<_>, x: i32| -> Result<i32, Infallible> {
             assert_eq!(x, 0);
             assert_eq!(HITS.fetch_add(1, SeqCst), 1);
@@ -244,7 +244,7 @@ fn static_function_with_results(config: crate::Config) -> Result<()> {
         },
     );
     let f2 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |_ctx: ContextMut<_>, x: i32, y: i64| {
             assert_eq!(x, 2);
             assert_eq!(y, 3);
@@ -252,7 +252,7 @@ fn static_function_with_results(config: crate::Config) -> Result<()> {
         },
     );
     let f3 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |_ctx: ContextMut<_>, a: i32, b: i64, c: i32, d: f32, e: f64| {
             assert_eq!(a, 100);
             assert_eq!(b, 200);
@@ -263,7 +263,7 @@ fn static_function_with_results(config: crate::Config) -> Result<()> {
         },
     );
     Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "host" => {
@@ -295,11 +295,11 @@ fn static_function_with_env(config: crate::Config) -> Result<()> {
 
     let env: Env = Env(Arc::new(AtomicUsize::new(0)));
     let mut ctx = WasmerContext::new(&store, env);
-    let f0 = Function::new_native(&mut ctx.as_context_mut(), |ctx: ContextMut<Env>| {
+    let f0 = Function::new_native(&mut ctx, |ctx: ContextMut<Env>| {
         assert_eq!(ctx.data().fetch_add(1, SeqCst), 0);
     });
     let f1 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |ctx: ContextMut<Env>, x: i32| -> i32 {
             assert_eq!(x, 0);
             assert_eq!(ctx.data().fetch_add(1, SeqCst), 1);
@@ -307,7 +307,7 @@ fn static_function_with_env(config: crate::Config) -> Result<()> {
         },
     );
     let f2 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |ctx: ContextMut<Env>, x: i32, y: i64| {
             assert_eq!(x, 2);
             assert_eq!(y, 3);
@@ -315,7 +315,7 @@ fn static_function_with_env(config: crate::Config) -> Result<()> {
         },
     );
     let f3 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |ctx: ContextMut<Env>, a: i32, b: i64, c: i32, d: f32, e: f64| {
             assert_eq!(a, 100);
             assert_eq!(b, 200);
@@ -326,7 +326,7 @@ fn static_function_with_env(config: crate::Config) -> Result<()> {
         },
     );
     Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "host" => {
@@ -356,13 +356,13 @@ fn static_function_that_fails(config: crate::Config) -> Result<()> {
     let module = Module::new(&store, &wat)?;
     let mut ctx = WasmerContext::new(&store, ());
     let f0 = Function::new_native(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         |_ctx: ContextMut<_>| -> Result<Infallible, RuntimeError> {
             Err(RuntimeError::new("oops"))
         },
     );
     let result = Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "host" => {
@@ -411,7 +411,7 @@ fn dynamic_function_with_env_wasmer_env_init_works(config: crate::Config) -> Res
     let env: Env = Env { memory: None };
     let mut ctx = WasmerContext::new(&store, env);
     let f0 = Function::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         FunctionType::new(vec![], vec![]),
         |ctx, _values| {
             assert!(ctx.data().memory.as_ref().is_some());
@@ -431,8 +431,8 @@ fn dynamic_function_with_env_wasmer_env_init_works(config: crate::Config) -> Res
     ctx.data_mut().memory = Some(memory.clone());
     let f: TypedFunction<(), ()> = instance
         .exports
-        .get_typed_function(&ctx.as_context_mut(), "main")?;
-    f.call(&mut ctx.as_context_mut())?;
+        .get_typed_function(&ctx, "main")?;
+    f.call(&mut ctx)?;
     Ok(())
 }
 
@@ -463,27 +463,27 @@ fn multi_use_host_fn_manages_memory_correctly(config: crate::Config) -> Result<(
     }
     let imports = imports! {
         "host" => {
-            "fn" => Function::new_native(&mut ctx.as_context_mut(), host_fn),
+            "fn" => Function::new_native(&mut ctx, host_fn),
         },
     };
-    let instance1 = Instance::new(&mut ctx.as_context_mut(), &module, &imports)?;
-    let instance2 = Instance::new(&mut ctx.as_context_mut(), &module, &imports)?;
+    let instance1 = Instance::new(&mut ctx, &module, &imports)?;
+    let instance2 = Instance::new(&mut ctx, &module, &imports)?;
     {
         let f1: TypedFunction<(), ()> = instance1
             .exports
-            .get_typed_function(&mut ctx.as_context_mut(), "main")?;
+            .get_typed_function(&mut ctx, "main")?;
         let memory = instance1.exports.get_memory("memory")?;
         ctx.data_mut().memory = Some(memory.clone());
-        f1.call(&mut ctx.as_context_mut())?;
+        f1.call(&mut ctx)?;
     }
     drop(instance1);
     {
         let f2: TypedFunction<(), ()> = instance2
             .exports
-            .get_typed_function(&mut ctx.as_context_mut(), "main")?;
+            .get_typed_function(&mut ctx, "main")?;
         let memory = instance2.exports.get_memory("memory")?;
         ctx.data_mut().memory = Some(memory.clone());
-        f2.call(&mut ctx.as_context_mut())?;
+        f2.call(&mut ctx)?;
     }
     drop(instance2);
     Ok(())
@@ -499,7 +499,7 @@ fn instance_local_memory_lifetime(config: crate::Config) -> Result<()> {
     (export "memory" (memory $mem))
 )"#;
         let module = Module::new(&store, wat)?;
-        let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})?;
+        let instance = Instance::new(&mut ctx, &module, &imports! {})?;
         instance.exports.get_memory("memory")?.clone()
     };
 
@@ -520,15 +520,15 @@ fn instance_local_memory_lifetime(config: crate::Config) -> Result<()> {
             "memory" => memory,
         },
     };
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports)?;
+    let instance = Instance::new(&mut ctx, &module, &imports)?;
     let set_at: TypedFunction<(i32, i32), ()> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "set_at")?;
+        .get_typed_function(&mut ctx, "set_at")?;
     let get_at: TypedFunction<i32, i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "get_at")?;
-    set_at.call(&mut ctx.as_context_mut(), 200, 123)?;
-    assert_eq!(get_at.call(&mut ctx.as_context_mut(), 200)?, 123);
+        .get_typed_function(&mut ctx, "get_at")?;
+    set_at.call(&mut ctx, 200, 123)?;
+    assert_eq!(get_at.call(&mut ctx, 200)?, 123);
 
     Ok(())
 }
diff --git a/tests/compilers/issues.rs b/tests/compilers/issues.rs
index a6409a30fe1..1db95f4ccbd 100644
--- a/tests/compilers/issues.rs
+++ b/tests/compilers/issues.rs
@@ -65,12 +65,12 @@ fn issue_2329(mut config: crate::Config) -> Result<()> {
     let imports: Imports = imports! {
         "env" => {
             "__read_memory" => Function::new_native(
-                &mut ctx.as_context_mut(),
+                &mut ctx,
                 read_memory
             ),
         }
     };
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports)?;
+    let instance = Instance::new(&mut ctx, &module, &imports)?;
     instance
         .exports
         .get_function("read_memory")?
@@ -189,7 +189,7 @@ fn call_with_static_data_pointers(mut config: crate::Config) -> Result<()> {
     let env = Env { memory: None };
     let mut ctx = WasmerContext::new(&store, env);
     let memory = Memory::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         MemoryType::new(Pages(1024), Some(Pages(2048)), false),
     )
     .unwrap();
@@ -198,24 +198,24 @@ fn call_with_static_data_pointers(mut config: crate::Config) -> Result<()> {
     exports.insert("memory", memory);
     exports.insert(
         "banana",
-        Function::new_native(&mut ctx.as_context_mut(), banana),
+        Function::new_native(&mut ctx, banana),
     );
     exports.insert(
         "peach",
-        Function::new_native(&mut ctx.as_context_mut(), peach),
+        Function::new_native(&mut ctx, peach),
     );
     exports.insert(
         "chaenomeles",
-        Function::new_native(&mut ctx.as_context_mut(), chaenomeles),
+        Function::new_native(&mut ctx, chaenomeles),
     );
     exports.insert(
         "mango",
-        Function::new_native(&mut ctx.as_context_mut(), mango),
+        Function::new_native(&mut ctx, mango),
     );
-    exports.insert("gas", Function::new_native(&mut ctx.as_context_mut(), gas));
+    exports.insert("gas", Function::new_native(&mut ctx, gas));
     let mut imports = Imports::new();
     imports.register_namespace("env", exports);
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports)?;
+    let instance = Instance::new(&mut ctx, &module, &imports)?;
     instance
         .exports
         .get_function("repro")?
diff --git a/tests/compilers/metering.rs b/tests/compilers/metering.rs
index 3e3f3c3259e..aaa3aa01487 100644
--- a/tests/compilers/metering.rs
+++ b/tests/compilers/metering.rs
@@ -25,11 +25,11 @@ fn run_add_with_limit(mut config: crate::Config, limit: u64) -> Result<()> {
     let import_object = imports! {};
 
     let module = Module::new(&store, wat).unwrap();
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let f: TypedFunction<(i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "add")?;
+        .get_typed_function(&mut ctx, "add")?;
     f.call(&mut ctx, 4, 6)?;
     Ok(())
 }
@@ -59,11 +59,11 @@ fn run_loop(mut config: crate::Config, limit: u64, iter_count: i32) -> Result<()
 
     let import_object = imports! {};
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let f: TypedFunction<i32, ()> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "test")?;
+        .get_typed_function(&mut ctx, "test")?;
     f.call(&mut ctx, iter_count)?;
     Ok(())
 }
@@ -165,15 +165,15 @@ fn complex_loop(mut config: crate::Config) -> Result<()> {
 
     let import_object = imports! {};
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let f: TypedFunction<(i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "add_to")?;
+        .get_typed_function(&mut ctx, "add_to")?;
 
     // FIXME: Since now a metering error is signaled with an `unreachable`, it is impossible to verify
     // the error type. Fix this later.
-    f.call(&mut ctx.as_context_mut(), 10_000_000, 4)
+    f.call(&mut ctx, 10_000_000, 4)
         .unwrap_err();
     Ok(())
 }
diff --git a/tests/compilers/middlewares.rs b/tests/compilers/middlewares.rs
index 04cb005689c..fabb2f894d7 100644
--- a/tests/compilers/middlewares.rs
+++ b/tests/compilers/middlewares.rs
@@ -104,12 +104,12 @@ fn middleware_basic(mut config: crate::Config) -> Result<()> {
 
     let import_object = imports! {};
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let f: TypedFunction<(i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "add")?;
-    let result = f.call(&mut ctx.as_context_mut(), 4, 6)?;
+        .get_typed_function(&mut ctx, "add")?;
+    let result = f.call(&mut ctx, 4, 6)?;
     assert_eq!(result, 24);
     Ok(())
 }
@@ -129,12 +129,12 @@ fn middleware_one_to_multi(mut config: crate::Config) -> Result<()> {
     let mut ctx = WasmerContext::new(&store, ());
     let import_object = imports! {};
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let f: TypedFunction<(i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "add")?;
-    let result = f.call(&mut ctx.as_context_mut(), 4, 6)?;
+        .get_typed_function(&mut ctx, "add")?;
+    let result = f.call(&mut ctx, 4, 6)?;
     assert_eq!(result, 25);
     Ok(())
 }
@@ -155,12 +155,12 @@ fn middleware_multi_to_one(mut config: crate::Config) -> Result<()> {
     let mut ctx = WasmerContext::new(&store, ());
     let import_object = imports! {};
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let f: TypedFunction<(i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "testfunc")?;
-    let result = f.call(&mut ctx.as_context_mut(), 10, 20)?;
+        .get_typed_function(&mut ctx, "testfunc")?;
+    let result = f.call(&mut ctx, 10, 20)?;
     assert_eq!(result, 10);
     Ok(())
 }
@@ -181,12 +181,12 @@ fn middleware_chain_order_1(mut config: crate::Config) -> Result<()> {
     let mut ctx = WasmerContext::new(&store, ());
     let import_object = imports! {};
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let f: TypedFunction<(i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "add")?;
-    let result = f.call(&mut ctx.as_context_mut(), 4, 6)?;
+        .get_typed_function(&mut ctx, "add")?;
+    let result = f.call(&mut ctx, 4, 6)?;
     assert_eq!(result, 24);
     Ok(())
 }
@@ -207,12 +207,12 @@ fn middleware_chain_order_2(mut config: crate::Config) -> Result<()> {
     let mut ctx = WasmerContext::new(&store, ());
     let import_object = imports! {};
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let f: TypedFunction<(i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "add")?;
-    let result = f.call(&mut ctx.as_context_mut(), 4, 6)?;
+        .get_typed_function(&mut ctx, "add")?;
+    let result = f.call(&mut ctx, 4, 6)?;
     assert_eq!(result, 48);
     Ok(())
 }
diff --git a/tests/compilers/native_functions.rs b/tests/compilers/native_functions.rs
index 75db75ae718..28ca6d8263d 100644
--- a/tests/compilers/native_functions.rs
+++ b/tests/compilers/native_functions.rs
@@ -63,29 +63,29 @@ fn native_function_works_for_wasm(config: crate::Config) -> anyhow::Result<()> {
 
     let import_object = imports! {
         "env" => {
-            "multiply" => Function::new_native(&mut ctx.as_context_mut(), |_ctx: ContextMut<_>, a: i32, b: i32| a * b),
+            "multiply" => Function::new_native(&mut ctx, |_ctx: ContextMut<_>, a: i32, b: i32| a * b),
         },
     };
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     {
         let f: TypedFunction<(i32, i32), i32> = instance
             .exports
-            .get_typed_function(&mut ctx.as_context_mut(), "add")?;
-        let result = f.call(&mut ctx.as_context_mut(), 4, 6)?;
+            .get_typed_function(&mut ctx, "add")?;
+        let result = f.call(&mut ctx, 4, 6)?;
         assert_eq!(result, 10);
     }
 
     {
         let f: &Function = instance.exports.get("double_then_add")?;
-        let result = f.call(&mut ctx.as_context_mut(), &[Value::I32(4), Value::I32(6)])?;
+        let result = f.call(&mut ctx, &[Value::I32(4), Value::I32(6)])?;
         assert_eq!(result[0], Value::I32(20));
     }
 
     {
         let dyn_f: &Function = instance.exports.get("double_then_add")?;
-        let f: TypedFunction<(i32, i32), i32> = dyn_f.native(&mut ctx.as_context_mut()).unwrap();
-        let result = f.call(&mut ctx.as_context_mut(), 4, 6)?;
+        let f: TypedFunction<(i32, i32), i32> = dyn_f.native(&mut ctx).unwrap();
+        let result = f.call(&mut ctx, 4, 6)?;
         assert_eq!(result, 20);
     }
 
@@ -101,7 +101,7 @@ fn native_function_works_for_wasm(config: crate::Config) -> anyhow::Result<()> {
 //    let mut ctx = WasmerContext::new(&store, ());
 //    let state = 3;
 //    Function::new_native(
-//        &mut ctx.as_context_mut(),
+//        &mut ctx,
 //        move |_ctx: ContextMut<_>, _: i32| {
 //            println!("{}", state);
 //        },
@@ -149,32 +149,32 @@ fn non_native_functions_and_closures_with_no_env_work(config: crate::Config) ->
     let captured_by_closure = 20;
     let import_object = imports! {
         "env" => {
-            "multiply1" => Function::new(&mut ctx.as_context_mut(), &ty, move |_ctx, args| {
+            "multiply1" => Function::new(&mut ctx, &ty, move |_ctx, args| {
                 if let (Value::I32(v1), Value::I32(v2)) = (&args[0], &args[1]) {
                     Ok(vec![Value::I32(v1 * v2 * captured_by_closure)])
                 } else {
                     panic!("Invalid arguments");
                 }
             }),
-            "multiply2" => Function::new(&mut ctx.as_context_mut(), &ty, move |ctx, args| {
+            "multiply2" => Function::new(&mut ctx, &ty, move |ctx, args| {
                 if let (Value::I32(v1), Value::I32(v2)) = (&args[0], &args[1]) {
                     Ok(vec![Value::I32(v1 * v2 * captured_by_closure * ctx.data())])
                 } else {
                     panic!("Invalid arguments");
                 }
             }),
-            "multiply3" => Function::new_native(&mut ctx.as_context_mut(), |_ctx: ContextMut<_>, arg1: i32, arg2: i32| -> i32
+            "multiply3" => Function::new_native(&mut ctx, |_ctx: ContextMut<_>, arg1: i32, arg2: i32| -> i32
                                                 {arg1 * arg2 }),
-            "multiply4" => Function::new_native(&mut ctx.as_context_mut(), |ctx: ContextMut<i32>, arg1: i32, arg2: i32| -> i32
+            "multiply4" => Function::new_native(&mut ctx, |ctx: ContextMut<i32>, arg1: i32, arg2: i32| -> i32
                                                          {arg1 * arg2 * ctx.data() }),
         },
     };
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     let test: TypedFunction<(i32, i32, i32, i32, i32), i32> = instance
         .exports
-        .get_typed_function(&mut ctx.as_context_mut(), "test")?;
+        .get_typed_function(&mut ctx, "test")?;
 
     let result = test.call(&mut ctx, 2, 3, 4, 5, 6)?;
     let manually_computed_result = 6 * (5 * (4 * (3 * 2 * 20) * 10 * 20)) * 10;
@@ -196,24 +196,24 @@ fn native_function_works_for_wasm_function_manyparams(config: crate::Config) ->
     let mut ctx = WasmerContext::new(&store, ());
     let import_object = imports! {
         "env" => {
-            "longf" => Function::new_native(&mut ctx.as_context_mut(), long_f),
+            "longf" => Function::new_native(&mut ctx, long_f),
         },
     };
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     {
         let dyn_f: &Function = instance.exports.get("longf")?;
-        let f: TypedFunction<(), i64> = dyn_f.native(&mut ctx.as_context_mut()).unwrap();
-        let result = f.call(&mut ctx.as_context_mut())?;
+        let f: TypedFunction<(), i64> = dyn_f.native(&mut ctx).unwrap();
+        let result = f.call(&mut ctx)?;
         assert_eq!(result, 1234567890);
     }
 
     {
         let dyn_f: &Function = instance.exports.get("longf_pure")?;
         let f: TypedFunction<(u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), i64> =
-            dyn_f.native(&mut ctx.as_context_mut()).unwrap();
-        let result = f.call(&mut ctx.as_context_mut(), 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
+            dyn_f.native(&mut ctx).unwrap();
+        let result = f.call(&mut ctx, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
         assert_eq!(result, 1234567890);
     }
 
@@ -237,24 +237,24 @@ fn native_function_works_for_wasm_function_manyparams_dynamic(
 
     let import_object = imports! {
         "env" => {
-            "longf" => Function::new(&mut ctx.as_context_mut(), FunctionType::new(vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I64 , ValueType::I64 ,ValueType::I32, ValueType::I32], vec![ValueType::I64]), long_f_dynamic),
+            "longf" => Function::new(&mut ctx, FunctionType::new(vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I64 , ValueType::I64 ,ValueType::I32, ValueType::I32], vec![ValueType::I64]), long_f_dynamic),
         },
     };
 
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &import_object)?;
+    let instance = Instance::new(&mut ctx, &module, &import_object)?;
 
     {
         let dyn_f: &Function = instance.exports.get("longf")?;
-        let f: TypedFunction<(), i64> = dyn_f.native(&mut ctx.as_context_mut()).unwrap();
-        let result = f.call(&mut ctx.as_context_mut())?;
+        let f: TypedFunction<(), i64> = dyn_f.native(&mut ctx).unwrap();
+        let result = f.call(&mut ctx)?;
         assert_eq!(result, 1234567890);
     }
 
     {
         let dyn_f: &Function = instance.exports.get("longf_pure")?;
         let f: TypedFunction<(u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), i64> =
-            dyn_f.native(&mut ctx.as_context_mut()).unwrap();
-        let result = f.call(&mut ctx.as_context_mut(), 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
+            dyn_f.native(&mut ctx).unwrap();
+        let result = f.call(&mut ctx, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
         assert_eq!(result, 1234567890);
     }
 
@@ -302,30 +302,30 @@ fn static_host_function_without_env(config: crate::Config) -> anyhow::Result<()>
 
     // Native static host function that returns a tuple.
     {
-        let f = Function::new_native(&mut ctx.as_context_mut(), f);
+        let f = Function::new_native(&mut ctx, f);
         let f_native: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-            f.native(&mut ctx.as_context_mut()).unwrap();
-        let result = f_native.call(&mut ctx.as_context_mut(), 1, 3, 5.0, 7.0)?;
+            f.native(&mut ctx).unwrap();
+        let result = f_native.call(&mut ctx, 1, 3, 5.0, 7.0)?;
         assert_eq!(result, (28.0, 15.0, 6, 1));
     }
 
     // Native static host function that returns a tuple.
     {
-        let long_f = Function::new_native(&mut ctx.as_context_mut(), long_f);
+        let long_f = Function::new_native(&mut ctx, long_f);
         let long_f_native: TypedFunction<
             (u32, u32, u32, u32, u32, u16, u64, u64, u16, u32),
             (u32, u64, u32),
-        > = long_f.native(&mut ctx.as_context_mut()).unwrap();
-        let result = long_f_native.call(&mut ctx.as_context_mut(), 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
+        > = long_f.native(&mut ctx).unwrap();
+        let result = long_f_native.call(&mut ctx, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
         assert_eq!(result, (654321, 87, 09));
     }
 
     // Native static host function that returns a result of a tuple.
     {
-        let f = Function::new_native(&mut ctx.as_context_mut(), f_ok);
+        let f = Function::new_native(&mut ctx, f_ok);
         let f_native: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-            f.native(&mut ctx.as_context_mut()).unwrap();
-        let result = f_native.call(&mut ctx.as_context_mut(), 1, 3, 5.0, 7.0)?;
+            f.native(&mut ctx).unwrap();
+        let result = f_native.call(&mut ctx, 1, 3, 5.0, 7.0)?;
         assert_eq!(result, (28.0, 15.0, 6, 1));
     }
 
@@ -373,13 +373,13 @@ fn static_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
         let env = Env(Arc::new(Mutex::new(100)));
         let mut ctx = WasmerContext::new(&store, env);
 
-        let f = Function::new_native(&mut ctx.as_context_mut(), f);
+        let f = Function::new_native(&mut ctx, f);
         let f_native: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-            f.native(&mut ctx.as_context_mut()).unwrap();
+            f.native(&mut ctx).unwrap();
 
         assert_eq!(*ctx.data_mut().0.lock().unwrap(), 100);
 
-        let result = f_native.call(&mut ctx.as_context_mut(), 1, 3, 5.0, 7.0)?;
+        let result = f_native.call(&mut ctx, 1, 3, 5.0, 7.0)?;
 
         assert_eq!(result, (28.0, 15.0, 6, 1));
         assert_eq!(*ctx.data_mut().0.lock().unwrap(), 101);
@@ -390,13 +390,13 @@ fn static_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
         let env = Env(Arc::new(Mutex::new(100)));
         let mut ctx = WasmerContext::new(&store, env);
 
-        let f = Function::new_native(&mut ctx.as_context_mut(), f_ok);
+        let f = Function::new_native(&mut ctx, f_ok);
         let f_native: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-            f.native(&mut ctx.as_context_mut()).unwrap();
+            f.native(&mut ctx).unwrap();
 
         assert_eq!(*ctx.data_mut().0.lock().unwrap(), 100);
 
-        let result = f_native.call(&mut ctx.as_context_mut(), 1, 3, 5.0, 7.0)?;
+        let result = f_native.call(&mut ctx, 1, 3, 5.0, 7.0)?;
 
         assert_eq!(result, (28.0, 15.0, 6, 1));
         assert_eq!(*ctx.data_mut().0.lock().unwrap(), 101);
@@ -410,7 +410,7 @@ fn dynamic_host_function_without_env(config: crate::Config) -> anyhow::Result<()
     let store = config.store();
     let mut ctx = WasmerContext::new(&store, ());
     let f = Function::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         FunctionType::new(
             vec![
                 ValueType::I32,
@@ -435,7 +435,7 @@ fn dynamic_host_function_without_env(config: crate::Config) -> anyhow::Result<()
         },
     );
     let f_native: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-        f.native(&mut ctx.as_context_mut()).unwrap();
+        f.native(&mut ctx).unwrap();
     let result = f_native.call(&mut ctx, 1, 3, 5.0, 7.0)?;
 
     assert_eq!(result, (28.0, 15.0, 6, 1));
@@ -460,7 +460,7 @@ fn dynamic_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
     let env = Env(Arc::new(Mutex::new(100)));
     let mut ctx = WasmerContext::new(&store, env);
     let f = Function::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         FunctionType::new(
             vec![
                 ValueType::I32,
@@ -491,7 +491,7 @@ fn dynamic_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
     );
 
     let f_native: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
-        f.native(&mut ctx.as_context_mut()).unwrap();
+        f.native(&mut ctx).unwrap();
 
     assert_eq!(*ctx.data().0.lock().unwrap(), 100);
 
diff --git a/tests/compilers/serialize.rs b/tests/compilers/serialize.rs
index fa9ea0465ad..96306f0666a 100644
--- a/tests/compilers/serialize.rs
+++ b/tests/compilers/serialize.rs
@@ -55,7 +55,7 @@ fn test_deserialize(config: crate::Config) -> Result<()> {
         vec![Type::I64],
     );
     let mut ctx = WasmerContext::new(&store, ());
-    let f0 = Function::new(&mut ctx.as_context_mut(), &func_type, |_ctx, params| {
+    let f0 = Function::new(&mut ctx, &func_type, |_ctx, params| {
         let param_0: i64 = params[0].unwrap_i32() as i64;
         let param_1: i64 = params[1].unwrap_i64() as i64;
         let param_2: i64 = params[2].unwrap_i32() as i64;
@@ -66,7 +66,7 @@ fn test_deserialize(config: crate::Config) -> Result<()> {
         )])
     });
     let instance = Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "host" => {
diff --git a/tests/compilers/traps.rs b/tests/compilers/traps.rs
index 396efcf6ab8..4516ad8b4e0 100644
--- a/tests/compilers/traps.rs
+++ b/tests/compilers/traps.rs
@@ -16,12 +16,12 @@ fn test_trap_return(config: crate::Config) -> Result<()> {
     let module = Module::new(&store, wat)?;
     let mut ctx = WasmerContext::new(&store, ());
     let hello_type = FunctionType::new(vec![], vec![]);
-    let hello_func = Function::new(&mut ctx.as_context_mut(), &hello_type, |_ctx, _| {
+    let hello_func = Function::new(&mut ctx, &hello_type, |_ctx, _| {
         Err(RuntimeError::new("test 123"))
     });
 
     let instance = Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "" => {
@@ -57,7 +57,7 @@ fn test_trap_trace(config: crate::Config) -> Result<()> {
 
     let mut ctx = WasmerContext::new(&store, ());
     let module = Module::new(&store, wat)?;
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})?;
+    let instance = Instance::new(&mut ctx, &module, &imports! {})?;
     let run_func = instance
         .exports
         .get_function("run")
@@ -98,13 +98,13 @@ fn test_trap_trace_cb(config: crate::Config) -> Result<()> {
 
     let mut ctx = WasmerContext::new(&store, ());
     let fn_type = FunctionType::new(vec![], vec![]);
-    let fn_func = Function::new(&mut ctx.as_context_mut(), &fn_type, |_ctx, _| {
+    let fn_func = Function::new(&mut ctx, &fn_type, |_ctx, _| {
         Err(RuntimeError::new("cb throw"))
     });
 
     let module = Module::new(&store, wat)?;
     let instance = Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "" => {
@@ -147,7 +147,7 @@ fn test_trap_stack_overflow(config: crate::Config) -> Result<()> {
 
     let module = Module::new(&store, wat)?;
     let mut ctx = WasmerContext::new(&store, ());
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})?;
+    let instance = Instance::new(&mut ctx, &module, &imports! {})?;
     let run_func = instance
         .exports
         .get_function("run")
@@ -181,7 +181,7 @@ fn trap_display_pretty(config: crate::Config) -> Result<()> {
 
     let module = Module::new(&store, wat)?;
     let mut ctx = WasmerContext::new(&store, ());
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})?;
+    let instance = Instance::new(&mut ctx, &module, &imports! {})?;
     let run_func = instance
         .exports
         .get_function("bar")
@@ -218,7 +218,7 @@ fn trap_display_multi_module(config: crate::Config) -> Result<()> {
 
     let module = Module::new(&store, wat)?;
     let mut ctx = WasmerContext::new(&store, ());
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})?;
+    let instance = Instance::new(&mut ctx, &module, &imports! {})?;
     let bar = instance.exports.get_function("bar")?.clone();
 
     let wat = r#"
@@ -230,7 +230,7 @@ fn trap_display_multi_module(config: crate::Config) -> Result<()> {
     "#;
     let module = Module::new(&store, wat)?;
     let instance = Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "" => {
@@ -274,11 +274,11 @@ fn trap_start_function_import(config: crate::Config) -> Result<()> {
     let module = Module::new(&store, &binary)?;
     let mut ctx = WasmerContext::new(&store, ());
     let sig = FunctionType::new(vec![], vec![]);
-    let func = Function::new(&mut ctx.as_context_mut(), &sig, |_ctx, _| {
+    let func = Function::new(&mut ctx, &sig, |_ctx, _| {
         Err(RuntimeError::new("user trap"))
     });
     let err = Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "" => {
@@ -317,14 +317,14 @@ fn rust_panic_import(config: crate::Config) -> Result<()> {
     let module = Module::new(&store, &binary)?;
     let mut ctx = WasmerContext::new(&store, ());
     let sig = FunctionType::new(vec![], vec![]);
-    let func = Function::new(&mut ctx.as_context_mut(), &sig, |_ctx, _| {
+    let func = Function::new(&mut ctx, &sig, |_ctx, _| {
         panic!("this is a panic")
     });
-    let f0 = Function::new_native(&mut ctx.as_context_mut(), |_ctx: ContextMut<_>| {
+    let f0 = Function::new_native(&mut ctx, |_ctx: ContextMut<_>| {
         panic!("this is another panic")
     });
     let instance = Instance::new(
-        &mut ctx.as_context_mut(),
+        &mut ctx,
         &module,
         &imports! {
             "" => {
@@ -367,12 +367,12 @@ fn rust_panic_start_function(config: crate::Config) -> Result<()> {
     let module = Module::new(&store, &binary)?;
     let mut ctx = WasmerContext::new(&store, ());
     let sig = FunctionType::new(vec![], vec![]);
-    let func = Function::new(&mut ctx.as_context_mut(), &sig, |_ctx, _| {
+    let func = Function::new(&mut ctx, &sig, |_ctx, _| {
         panic!("this is a panic")
     });
     let err = panic::catch_unwind(AssertUnwindSafe(|| {
         drop(Instance::new(
-            &mut ctx.as_context_mut(),
+            &mut ctx,
             &module,
             &imports! {
                 "" => {
@@ -384,12 +384,12 @@ fn rust_panic_start_function(config: crate::Config) -> Result<()> {
     .unwrap_err();
     assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
 
-    let func = Function::new_native(&mut ctx.as_context_mut(), |_ctx: ContextMut<_>| {
+    let func = Function::new_native(&mut ctx, |_ctx: ContextMut<_>| {
         panic!("this is another panic")
     });
     let err = panic::catch_unwind(AssertUnwindSafe(|| {
         drop(Instance::new(
-            &mut ctx.as_context_mut(),
+            &mut ctx,
             &module,
             &imports! {
                 "" => {
@@ -417,22 +417,22 @@ fn mismatched_arguments(config: crate::Config) -> Result<()> {
 
     let module = Module::new(&store, &binary)?;
     let mut ctx = WasmerContext::new(&store, ());
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})?;
+    let instance = Instance::new(&mut ctx, &module, &imports! {})?;
     let func: &Function = instance.exports.get("foo")?;
     assert_eq!(
-        func.call(&mut ctx.as_context_mut(), &[])
+        func.call(&mut ctx, &[])
             .unwrap_err()
             .message(),
         "Parameters of type [] did not match signature [I32] -> []"
     );
     assert_eq!(
-        func.call(&mut ctx.as_context_mut(), &[Value::F32(0.0)])
+        func.call(&mut ctx, &[Value::F32(0.0)])
             .unwrap_err()
             .message(),
         "Parameters of type [F32] did not match signature [I32] -> []",
     );
     assert_eq!(
-        func.call(&mut ctx.as_context_mut(), &[Value::I32(0), Value::I32(1)])
+        func.call(&mut ctx, &[Value::I32(0), Value::I32(1)])
             .unwrap_err()
             .message(),
         "Parameters of type [I32, I32] did not match signature [I32] -> []"
@@ -459,7 +459,7 @@ fn call_signature_mismatch(config: crate::Config) -> Result<()> {
 
     let module = Module::new(&store, &binary)?;
     let mut ctx = WasmerContext::new(&store, ());
-    let err = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})
+    let err = Instance::new(&mut ctx, &module, &imports! {})
         .err()
         .expect("expected error");
     assert_eq!(
@@ -488,7 +488,7 @@ fn start_trap_pretty(config: crate::Config) -> Result<()> {
 
     let module = Module::new(&store, wat)?;
     let mut ctx = WasmerContext::new(&store, ());
-    let err = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})
+    let err = Instance::new(&mut ctx, &module, &imports! {})
         .err()
         .expect("expected error");
 
@@ -510,15 +510,15 @@ fn present_after_module_drop(config: crate::Config) -> Result<()> {
     let store = config.store();
     let module = Module::new(&store, r#"(func (export "foo") unreachable)"#)?;
     let mut ctx = WasmerContext::new(&store, ());
-    let instance = Instance::new(&mut ctx.as_context_mut(), &module, &imports! {})?;
+    let instance = Instance::new(&mut ctx, &module, &imports! {})?;
     let func: Function = instance.exports.get_function("foo")?.clone();
 
     println!("asserting before we drop modules");
-    assert_trap(func.call(&mut ctx.as_context_mut(), &[]).unwrap_err());
+    assert_trap(func.call(&mut ctx, &[]).unwrap_err());
     drop((instance, module));
 
     println!("asserting after drop");
-    assert_trap(func.call(&mut ctx.as_context_mut(), &[]).unwrap_err());
+    assert_trap(func.call(&mut ctx, &[]).unwrap_err());
     return Ok(());
 
     fn assert_trap(t: RuntimeError) {