From 6a1824b7cd18fcc5d9a2433d0bce9a8d2126c00e Mon Sep 17 00:00:00 2001 From: Syrus Akbary Date: Thu, 23 Jun 2022 18:54:03 -0700 Subject: [PATCH] Simplified api calls --- lib/api/tests/js_externals.rs | 188 +++++++++++++++++----------------- lib/api/tests/js_instance.rs | 94 ++++++++--------- 2 files changed, 141 insertions(+), 141 deletions(-) diff --git a/lib/api/tests/js_externals.rs b/lib/api/tests/js_externals.rs index 7d05cac38a9..1d5c8d18d31 100644 --- a/lib/api/tests/js_externals.rs +++ b/lib/api/tests/js_externals.rs @@ -7,18 +7,18 @@ mod js { fn global_new() { let store = Store::default(); let mut ctx = Context::new(&store, ()); - let global = Global::new(&mut ctx.as_context_mut(), Value::I32(10)); + let global = Global::new(&mut ctx, Value::I32(10)); assert_eq!( - global.ty(&ctx.as_context_ref()), + global.ty(&ctx), GlobalType { ty: Type::I32, mutability: Mutability::Const } ); - let global_mut = Global::new_mut(&mut ctx.as_context_mut(), Value::I32(10)); + let global_mut = Global::new_mut(&mut ctx, Value::I32(10)); assert_eq!( - global_mut.ty(&ctx.as_context_ref()), + global_mut.ty(&ctx), GlobalType { ty: Type::I32, mutability: Mutability::Var @@ -30,15 +30,15 @@ mod js { fn global_get() { let store = Store::default(); let mut ctx = Context::new(&store, ()); - let global_i32 = Global::new(&mut ctx.as_context_mut(), Value::I32(10)); - assert_eq!(global_i32.get(&ctx.as_context_ref()), Value::I32(10)); + let global_i32 = Global::new(&mut ctx, Value::I32(10)); + assert_eq!(global_i32.get(&ctx), Value::I32(10)); // 64-bit values are not yet fully supported in some versions of Node // Commenting this tests for now: // let global_i64 = Global::new(&store, Value::I64(20)); // assert_eq!(global_i64.get(), Value::I64(20)); - let global_f32 = Global::new(&mut ctx.as_context_mut(), Value::F32(10.0)); - assert_eq!(global_f32.get(&ctx.as_context_ref()), Value::F32(10.0)); + let global_f32 = Global::new(&mut ctx, Value::F32(10.0)); + assert_eq!(global_f32.get(&ctx), Value::F32(10.0)); // let global_f64 = Global::new(&store, Value::F64(20.0)); // assert_eq!(global_f64.get(), Value::F64(20.0)); } @@ -47,23 +47,23 @@ mod js { fn global_set() { let store = Store::default(); let mut ctx = Context::new(&store, ()); - let global_i32 = Global::new(&mut ctx.as_context_mut(), Value::I32(10)); + let global_i32 = Global::new(&mut ctx, Value::I32(10)); // Set on a constant should error assert!(global_i32 - .set(&mut ctx.as_context_mut(), Value::I32(20)) + .set(&mut ctx, Value::I32(20)) .is_err()); - let global_i32_mut = Global::new_mut(&mut ctx.as_context_mut(), Value::I32(10)); + let global_i32_mut = Global::new_mut(&mut ctx, Value::I32(10)); // Set on different type should error assert!(global_i32_mut - .set(&mut ctx.as_context_mut(), Value::I64(20)) + .set(&mut ctx, Value::I64(20)) .is_err()); // Set on same type should succeed global_i32_mut - .set(&mut ctx.as_context_mut(), Value::I32(20)) + .set(&mut ctx, Value::I32(20)) .unwrap(); - assert_eq!(global_i32_mut.get(&ctx.as_context_ref()), Value::I32(20)); + assert_eq!(global_i32_mut.get(&ctx), Value::I32(20)); } #[wasm_bindgen_test] @@ -75,14 +75,14 @@ mod js { minimum: 0, maximum: None, }; - let f = Function::new_native(&mut ctx.as_context_mut(), |_: ContextMut<'_, ()>| {}); + let f = Function::new_native(&mut ctx, |_: ContextMut<'_, ()>| {}); let table = Table::new( - &mut ctx.as_context_mut(), + &mut ctx, table_type, Value::FuncRef(Some(f)), ) .unwrap(); - assert_eq!(table.ty(&ctx.as_context_ref()), table_type); + assert_eq!(table.ty(&ctx), table_type); // table.get() // Anyrefs not yet supported @@ -92,7 +92,7 @@ mod js { // maximum: None, // }; // let table = Table::new(&store, table_type, Value::ExternRef(ExternRef::Null))?; - // assert_eq!(*table.ty(&ctx.as_context_ref()), table_type); + // assert_eq!(*table.ty(&ctx), table_type); } // Tables are not yet fully supported in Wasm @@ -108,9 +108,9 @@ mod js { // minimum: 0, // maximum: Some(1), // }; - // let f = Function::new(&mut ctx.as_context_mut(), |num: i32| num + 1); + // let f = Function::new(&mut ctx, |num: i32| num + 1); // let table = Table::new(&store, table_type, Value::FuncRef(Some(f.clone())))?; - // assert_eq!(*table.ty(&ctx.as_context_ref()), table_type); + // assert_eq!(*table.ty(&ctx), table_type); // let _elem = table.get(0).unwrap(); // // assert_eq!(elem.funcref().unwrap(), f); // Ok(()) @@ -132,7 +132,7 @@ mod js { // minimum: 0, // maximum: Some(10), // }; - // let f = Function::new(&mut ctx.as_context_mut(), |num: i32| num + 1); + // let f = Function::new(&mut ctx, |num: i32| num + 1); // let table = Table::new(&store, table_type, Value::FuncRef(Some(f.clone())))?; // // Growing to a bigger maximum should return None // let old_len = table.grow(12, Value::FuncRef(Some(f.clone()))); @@ -161,9 +161,9 @@ mod js { minimum: Pages(0), maximum: Some(Pages(10)), }; - let memory = Memory::new(&mut ctx.as_context_mut(), memory_type).unwrap(); - assert_eq!(memory.size(&ctx.as_context_ref()), Pages(0)); - assert_eq!(memory.ty(&ctx.as_context_ref()), memory_type); + let memory = Memory::new(&mut ctx, memory_type).unwrap(); + assert_eq!(memory.size(&ctx), Pages(0)); + assert_eq!(memory.ty(&ctx), memory_type); } #[wasm_bindgen_test] @@ -172,14 +172,14 @@ mod js { let mut ctx = Context::new(&store, ()); let desc = MemoryType::new(Pages(10), Some(Pages(16)), false); - let memory = Memory::new(&mut ctx.as_context_mut(), desc).unwrap(); - assert_eq!(memory.size(&ctx.as_context_ref()), Pages(10)); + let memory = Memory::new(&mut ctx, desc).unwrap(); + assert_eq!(memory.size(&ctx), Pages(10)); - let result = memory.grow(&mut ctx.as_context_mut(), Pages(2)).unwrap(); + let result = memory.grow(&mut ctx, Pages(2)).unwrap(); assert_eq!(result, Pages(10)); - assert_eq!(memory.size(&ctx.as_context_ref()), Pages(12)); + assert_eq!(memory.size(&ctx), Pages(12)); - let result = memory.grow(&mut ctx.as_context_mut(), Pages(10)); + let result = memory.grow(&mut ctx, Pages(10)); assert!(result.is_err()); assert_eq!( result, @@ -195,41 +195,41 @@ mod js { let store = Store::default(); let mut ctx = Context::new(&store, ()); let function = - Function::new_native(&mut ctx.as_context_mut(), |_ctx: ContextMut<'_, ()>| {}); + Function::new_native(&mut ctx, |_ctx: ContextMut<'_, ()>| {}); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![], vec![]) ); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_ctx: ContextMut<'_, ()>, _a: i32| {}, ); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![Type::I32], vec![]) ); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_ctx: ContextMut<'_, ()>, _a: i32, _b: i64, _c: f32, _d: f64| {}, ); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]) ); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_ctx: ContextMut<'_, ()>| -> i32 { 1 }, ); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![], vec![Type::I32]) ); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_ctx: ContextMut<'_, ()>| -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) }, ); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]) ); } @@ -244,41 +244,41 @@ mod js { let mut ctx = Context::new(&store, my_env); let function = - Function::new_native(&mut ctx.as_context_mut(), |_: ContextMut<'_, MyEnv>| {}); + Function::new_native(&mut ctx, |_: ContextMut<'_, MyEnv>| {}); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![], vec![]) ); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_: ContextMut<'_, MyEnv>, _a: i32| {}, ); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![Type::I32], vec![]) ); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_: ContextMut<'_, MyEnv>, _a: i32, _b: i64, _c: f32, _d: f64| {}, ); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]) ); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_: ContextMut<'_, MyEnv>| -> i32 { 1 }, ); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![], vec![Type::I32]) ); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_: ContextMut<'_, MyEnv>| -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) }, ); assert_eq!( - function.ty(&ctx.as_context_ref()).clone(), + function.ty(&ctx).clone(), FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]) ); } @@ -291,52 +291,52 @@ mod js { // Using &FunctionType signature let function_type = FunctionType::new(vec![], vec![]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, ()>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); let function_type = FunctionType::new(vec![Type::I32], vec![]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, ()>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); let function_type = FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, ()>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); let function_type = FunctionType::new(vec![], vec![Type::I32]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, ()>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); let function_type = FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, ()>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); // Using array signature let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, function_type, |_ctx: ContextMut<'_, ()>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).params(), [Type::V128]); + assert_eq!(function.ty(&ctx).params(), [Type::V128]); assert_eq!( - function.ty(&ctx.as_context_ref()).results(), + function.ty(&ctx).results(), [Type::I32, Type::F32, Type::F64] ); } @@ -353,52 +353,52 @@ mod js { // Using &FunctionType signature let function_type = FunctionType::new(vec![], vec![]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, MyEnv>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); let function_type = FunctionType::new(vec![Type::I32], vec![]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, MyEnv>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); let function_type = FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, MyEnv>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); let function_type = FunctionType::new(vec![], vec![Type::I32]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, MyEnv>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); let function_type = FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &function_type, |_ctx: ContextMut<'_, MyEnv>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).clone(), function_type); + assert_eq!(function.ty(&ctx).clone(), function_type); // Using array signature let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]); let function = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, function_type, |_ctx: ContextMut<'_, MyEnv>, _values: &[Value]| unimplemented!(), ); - assert_eq!(function.ty(&ctx.as_context_ref()).params(), [Type::V128]); + assert_eq!(function.ty(&ctx).params(), [Type::V128]); assert_eq!( - function.ty(&ctx.as_context_ref()).results(), + function.ty(&ctx).results(), [Type::I32, Type::F32, Type::F64] ); } @@ -407,48 +407,48 @@ mod js { fn native_function_works() { let store = Store::default(); let mut ctx = Context::new(&store, ()); - let function = Function::new_native(&mut ctx.as_context_mut(), |_: ContextMut<'_, ()>| {}); + let function = Function::new_native(&mut ctx, |_: ContextMut<'_, ()>| {}); let typed_function: TypedFunction<(), ()> = - function.native(&mut ctx.as_context_mut()).unwrap(); - let result = typed_function.call(&mut ctx.as_context_mut()); + function.native(&mut ctx).unwrap(); + let result = typed_function.call(&mut ctx); assert!(result.is_ok()); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_: ContextMut<'_, ()>, a: i32| -> i32 { a + 1 }, ); let typed_function: TypedFunction = - function.native(&mut ctx.as_context_mut()).unwrap(); + function.native(&mut ctx).unwrap(); assert_eq!( - typed_function.call(&mut ctx.as_context_mut(), 3).unwrap(), + typed_function.call(&mut ctx, 3).unwrap(), 4 ); // fn rust_abi(a: i32, b: i64, c: f32, d: f64) -> u64 { // (a as u64 * 1000) + (b as u64 * 100) + (c as u64 * 10) + (d as u64) // } - // let function = Function::new(&mut ctx.as_context_mut(), rust_abi); - // let typed_function: TypedFunction<(i32, i64, f32, f64), u64> = function.native(&mut ctx.as_context_mut()).unwrap(); + // let function = Function::new(&mut ctx, rust_abi); + // let typed_function: TypedFunction<(i32, i64, f32, f64), u64> = function.native(&mut ctx).unwrap(); // assert_eq!(typed_function.call(8, 4, 1.5, 5.).unwrap(), 8415); let function = - Function::new_native(&mut ctx.as_context_mut(), |_: ContextMut<'_, ()>| -> i32 { + Function::new_native(&mut ctx, |_: ContextMut<'_, ()>| -> i32 { 1 }); let typed_function: TypedFunction<(), i32> = - function.native(&mut ctx.as_context_mut()).unwrap(); - assert_eq!(typed_function.call(&mut ctx.as_context_mut()).unwrap(), 1); + function.native(&mut ctx).unwrap(); + assert_eq!(typed_function.call(&mut ctx).unwrap(), 1); let function = Function::new_native( - &mut ctx.as_context_mut(), + &mut ctx, |_: ContextMut<'_, ()>, _a: i32| {}, ); let typed_function: TypedFunction = - function.native(&mut ctx.as_context_mut()).unwrap(); - assert!(typed_function.call(&mut ctx.as_context_mut(), 4).is_ok()); + function.native(&mut ctx).unwrap(); + assert!(typed_function.call(&mut ctx, 4).is_ok()); - // let function = Function::new(&mut ctx.as_context_mut(), || -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) }); - // let typed_function: TypedFunction<(), (i32, i64, f32, f64)> = function.native(&mut ctx.as_context_mut()).unwrap(); + // let function = Function::new(&mut ctx, || -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) }); + // let typed_function: TypedFunction<(), (i32, i64, f32, f64)> = function.native(&mut ctx).unwrap(); // assert_eq!(typed_function.call().unwrap(), (1, 2, 3.0, 4.0)); } @@ -470,11 +470,11 @@ mod js { let instance = Instance::new(&mut ctx, &module, &imports! {}).unwrap(); let f = instance .exports - .get_function(&mut ctx.as_context_mut(), "sum") + .get_function(&mut ctx, "sum") .unwrap(); assert_eq!( - f.call(&mut ctx.as_context_mut(), &[Val::I32(4), Val::I32(5)]) + f.call(&mut ctx, &[Val::I32(4), Val::I32(5)]) .unwrap(), vec![Val::I32(9)].into_boxed_slice() ); @@ -482,7 +482,7 @@ mod js { }; assert_eq!( - f.call(&mut ctx.as_context_mut(), &[Val::I32(4), Val::I32(5)]) + f.call(&mut ctx, &[Val::I32(4), Val::I32(5)]) .unwrap(), vec![Val::I32(9)].into_boxed_slice() ); diff --git a/lib/api/tests/js_instance.rs b/lib/api/tests/js_instance.rs index 78fdea46317..5255bf6fe65 100644 --- a/lib/api/tests/js_instance.rs +++ b/lib/api/tests/js_instance.rs @@ -86,7 +86,7 @@ mod js { let get_magic = instance .exports - .get_function(&ctx.as_context_ref(), "get_magic") + .get_function(&ctx, "get_magic") .unwrap(); assert_eq!( get_magic.ty(&ctx).clone(), @@ -95,7 +95,7 @@ mod js { let expected = vec![Val::I32(42)].into_boxed_slice(); assert_eq!( - get_magic.call(&mut ctx.as_context_mut(), &[]).unwrap(), + get_magic.call(&mut ctx, &[]).unwrap(), expected ); } @@ -132,7 +132,7 @@ mod js { let imported_signature = FunctionType::new(vec![Type::I32], vec![Type::I32]); let imported = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, imported_signature, |env, args| { log!("Calling `imported`..."); @@ -151,13 +151,13 @@ mod js { let exported = instance .exports - .get_function(&ctx.as_context_ref(), "exported") + .get_function(&ctx, "exported") .unwrap(); let expected = vec![Val::I32(6)].into_boxed_slice(); assert_eq!( exported - .call(&mut ctx.as_context_mut(), &[Val::I32(3)]) + .call(&mut ctx, &[Val::I32(3)]) .unwrap(), expected ); @@ -260,7 +260,7 @@ mod js { let imported_signature = FunctionType::new(vec![Type::I32], vec![Type::I32]); let imported = Function::new( - &mut ctx.as_context_mut(), + &mut ctx, &imported_signature, |ctx, args| { log!("Calling `imported`..."); @@ -279,12 +279,12 @@ mod js { let exported = instance .exports - .get_function(&ctx.as_context_ref(), "exported") + .get_function(&ctx, "exported") .unwrap(); let expected = vec![Val::I32(9)].into_boxed_slice(); assert_eq!( - exported.call(&mut ctx.as_context_mut(), &[Val::I32(3)]), + exported.call(&mut ctx, &[Val::I32(3)]), Ok(expected) ); } @@ -322,7 +322,7 @@ mod js { } let mut ctx = Context::new(&store, ()); - let imported = Function::new_native(&mut ctx.as_context_mut(), imported_fn); + let imported = Function::new_native(&mut ctx, imported_fn); let import_object = imports! { "env" => { @@ -333,12 +333,12 @@ mod js { let exported = instance .exports - .get_function(&ctx.as_context_ref(), "exported") + .get_function(&ctx, "exported") .unwrap(); let expected = vec![Val::I32(5)].into_boxed_slice(); assert_eq!( - exported.call(&mut ctx.as_context_mut(), &[Val::I32(4)]), + exported.call(&mut ctx, &[Val::I32(4)]), Ok(expected) ); } @@ -395,13 +395,13 @@ mod js { let exported = instance .exports - .get_function(&ctx.as_context_ref(), "exported") + .get_function(&ctx, "exported") .unwrap(); let expected = vec![Val::I32(12)].into_boxed_slice(); ctx.data_mut().multiplier = 3; assert_eq!( - exported.call(&mut ctx.as_context_mut(), &[Val::I32(4)]), + exported.call(&mut ctx, &[Val::I32(4)]), Ok(expected) ); } @@ -454,7 +454,7 @@ mod js { memory: None, }, ); - let imported = Function::new_native(&mut ctx.as_context_mut(), imported_fn); + let imported = Function::new_native(&mut ctx, imported_fn); let import_object = imports! { "env" => { @@ -476,7 +476,7 @@ mod js { let exported = instance .exports - .get_function(&ctx.as_context_ref(), "exported") + .get_function(&ctx, "exported") .unwrap(); // It works with the provided memory @@ -487,7 +487,7 @@ mod js { memory.uint8view(&ctx).set_index(0, 3); let expected = vec![Val::I32(36)].into_boxed_slice(); assert_eq!( - exported.call(&mut ctx.as_context_mut(), &[Val::I32(4)]), + exported.call(&mut ctx, &[Val::I32(4)]), Ok(expected) ); } @@ -508,11 +508,11 @@ mod js { } let imported_signature = FunctionType::new(vec![Type::I32], vec![Type::I32]); - let imported = Function::new(&mut ctx.as_context_mut(), imported_signature, imported_fn); + let imported = Function::new(&mut ctx, imported_signature, imported_fn); let expected = vec![Val::I32(12)].into_boxed_slice(); assert_eq!( - imported.call(&mut ctx.as_context_mut(), &[Val::I32(4)]), + imported.call(&mut ctx, &[Val::I32(4)]), Ok(expected) ); } @@ -554,7 +554,7 @@ mod js { fn imported_fn(ctx: ContextMut<'_, Env>, args: &[Val]) -> Result, RuntimeError> { let memory: &Memory = ctx.data().memory.as_ref().unwrap(); - let memory_val = memory.uint8view(&ctx.as_context_ref()).get_index(0); + let memory_val = memory.uint8view(&ctx).get_index(0); let value = (memory_val as u32) * ctx.data().multiplier * args[0].unwrap_i32() as u32; return Ok(vec![Val::I32(value as _)]); } @@ -579,21 +579,21 @@ mod js { let memory = instance .exports - .get_memory(&ctx.as_context_ref(), "memory") + .get_memory(&ctx, "memory") .unwrap(); - assert_eq!(memory.data_size(&ctx.as_context_ref()), 65536); - let memory_val = memory.uint8view(&ctx.as_context_ref()).get_index(0); + assert_eq!(memory.data_size(&ctx), 65536); + let memory_val = memory.uint8view(&ctx).get_index(0); assert_eq!(memory_val, 0); - memory.uint8view(&ctx.as_context_ref()).set_index(0, 2); - let memory_val = memory.uint8view(&ctx.as_context_ref()).get_index(0); + memory.uint8view(&ctx).set_index(0, 2); + let memory_val = memory.uint8view(&ctx).get_index(0); assert_eq!(memory_val, 2); ctx.data_mut().memory = Some(memory.clone()); let exported = instance .exports - .get_function(&ctx.as_context_ref(), "exported") + .get_function(&ctx, "exported") .unwrap(); // It works with the provided memory @@ -601,10 +601,10 @@ mod js { assert_eq!(exported.call(&mut ctx, &[Val::I32(4)]), Ok(expected)); // It works if we update the memory - memory.uint8view(&ctx.as_context_ref()).set_index(0, 3); + memory.uint8view(&ctx).set_index(0, 3); let expected = vec![Val::I32(36)].into_boxed_slice(); assert_eq!( - exported.call(&mut ctx.as_context_mut(), &[Val::I32(4)]), + exported.call(&mut ctx, &[Val::I32(4)]), Ok(expected) ); } @@ -638,7 +638,7 @@ mod js { }) .unwrap(); let mut ctx = Context::new(&store, ()); - let global = Global::new_mut(&mut ctx.as_context_mut(), Value::I32(0)); + let global = Global::new_mut(&mut ctx, Value::I32(0)); let import_object = imports! { "" => { "global" => global.clone() @@ -648,31 +648,31 @@ mod js { let get_global = instance .exports - .get_function(&ctx.as_context_ref(), "getGlobal") + .get_function(&ctx, "getGlobal") .unwrap(); assert_eq!( - get_global.call(&mut ctx.as_context_mut(), &[]), + get_global.call(&mut ctx, &[]), Ok(vec![Val::I32(0)].into_boxed_slice()) ); global - .set(&mut ctx.as_context_mut(), Value::I32(42)) + .set(&mut ctx, Value::I32(42)) .unwrap(); assert_eq!( - get_global.call(&mut ctx.as_context_mut(), &[]), + get_global.call(&mut ctx, &[]), Ok(vec![Val::I32(42)].into_boxed_slice()) ); let inc_global = instance .exports - .get_function(&ctx.as_context_ref(), "incGlobal") + .get_function(&ctx, "incGlobal") .unwrap(); - inc_global.call(&mut ctx.as_context_mut(), &[]).unwrap(); + inc_global.call(&mut ctx, &[]).unwrap(); assert_eq!( - get_global.call(&mut ctx.as_context_mut(), &[]), + get_global.call(&mut ctx, &[]), Ok(vec![Val::I32(43)].into_boxed_slice()) ); - assert_eq!(global.get(&ctx.as_context_ref()), Val::I32(43)); + assert_eq!(global.get(&ctx), Val::I32(43)); } #[wasm_bindgen_test] @@ -705,9 +705,9 @@ mod js { let add_one: TypedFunction = instance .exports - .get_typed_function(&ctx.as_context_ref(), "add_one") + .get_typed_function(&ctx, "add_one") .unwrap(); - assert_eq!(add_one.call(&mut ctx.as_context_mut(), 1), Ok(2)); + assert_eq!(add_one.call(&mut ctx, 1), Ok(2)); } #[wasm_bindgen_test] @@ -744,21 +744,21 @@ mod js { let run_func: TypedFunction<(i32, i32), i32> = instance .exports - .get_typed_function(&ctx.as_context_ref(), "run") + .get_typed_function(&ctx, "run") .unwrap(); assert!( - run_func.call(&mut ctx.as_context_mut(), 1, 7).is_err(), + run_func.call(&mut ctx, 1, 7).is_err(), "Expected early termination", ); let run_func = instance .exports - .get_function(&ctx.as_context_ref(), "run") + .get_function(&ctx, "run") .unwrap(); assert!( run_func - .call(&mut ctx.as_context_mut(), &[Val::I32(1), Val::I32(7)]) + .call(&mut ctx, &[Val::I32(1), Val::I32(7)]) .is_err(), "Expected early termination", ); @@ -805,7 +805,7 @@ mod js { let import_object = imports! { "env" => { - "early_exit" => Function::new_native(&mut ctx.as_context_mut(), early_exit), + "early_exit" => Function::new_native(&mut ctx, early_exit), } }; @@ -836,15 +836,15 @@ mod js { let run_func: TypedFunction<(i32, i32), i32> = instance .exports - .get_typed_function(&ctx.as_context_ref(), "run") + .get_typed_function(&ctx, "run") .unwrap(); - test_result(run_func.call(&mut ctx.as_context_mut(), 1, 7)); + test_result(run_func.call(&mut ctx, 1, 7)); let run_func = instance .exports - .get_function(&ctx.as_context_ref(), "run") + .get_function(&ctx, "run") .unwrap(); - test_result(run_func.call(&mut ctx.as_context_mut(), &[Val::I32(1), Val::I32(7)])); + test_result(run_func.call(&mut ctx, &[Val::I32(1), Val::I32(7)])); } #[wasm_bindgen_test]