fix another provenance/lazy-init issue

Signed-off-by: Joel Dice <joel.dice@fermyon.com>

Author: dicej

crates/wasmtime/src/runtime/func.rs

@@ -1044,7 +1044,8 @@ impl Func {
         params_and_returns: NonNull<[ValRaw]>,
     ) -> Result<()> {
         invoke_wasm_and_catch_traps(store, |caller, vm| {
-            func_ref.as_ref().array_call(
+            VMFuncRef::array_call(
+                func_ref,
                 vm,
                 VMOpaqueContext::from_vmcontext(caller),
                 params_and_returns,

crates/wasmtime/src/runtime/func/typed.rs

@@ -235,9 +235,12 @@ where
             let storage = storage.cast::<ValRaw>();
             let storage = core::ptr::slice_from_raw_parts_mut(storage, storage_len);
             let storage = NonNull::new(storage).unwrap();
-            func_ref
-                .as_ref()
-                .array_call(vm, VMOpaqueContext::from_vmcontext(caller), storage)
+            VMFuncRef::array_call(
+                *func_ref,
+                vm,
+                VMOpaqueContext::from_vmcontext(caller),
+                storage,
+            )
         });
 
         let (_, storage) = captures;

crates/wasmtime/src/runtime/instance.rs

@@ -341,7 +341,8 @@ impl Instance {
         let caller_vmctx = instance.vmctx();
         unsafe {
             super::func::invoke_wasm_and_catch_traps(store, |_default_caller, vm| {
-                f.func_ref.as_ref().array_call(
+                VMFuncRef::array_call(
+                    f.func_ref,
                     vm,
                     VMOpaqueContext::from_vmcontext(caller_vmctx),
                     NonNull::from(&mut []),

crates/wasmtime/src/runtime/vm/vmcontext.rs

@@ -869,42 +869,42 @@ impl VMFuncRef {
     /// exhaustively documented.
     #[inline]
     pub unsafe fn array_call(
-        &self,
+        me: NonNull<Self>,
         pulley: Option<InterpreterRef<'_>>,
         caller: NonNull<VMOpaqueContext>,
         args_and_results: NonNull<[ValRaw]>,
     ) -> bool {
         match pulley {
-            Some(vm) => self.array_call_interpreted(vm, caller, args_and_results),
-            None => self.array_call_native(caller, args_and_results),
+            Some(vm) => Self::array_call_interpreted(me, vm, caller, args_and_results),
+            None => Self::array_call_native(me, caller, args_and_results),
         }
     }
 
     unsafe fn array_call_interpreted(
-        &self,
+        me: NonNull<Self>,
         vm: InterpreterRef<'_>,
         caller: NonNull<VMOpaqueContext>,
         args_and_results: NonNull<[ValRaw]>,
     ) -> bool {
         // If `caller` is actually a `VMArrayCallHostFuncContext` then skip the
         // interpreter, even though it's available, as `array_call` will be
         // native code.
-        if self.vmctx.as_non_null().as_ref().magic
+        if me.as_ref().vmctx.as_non_null().as_ref().magic
             == wasmtime_environ::VM_ARRAY_CALL_HOST_FUNC_MAGIC
         {
-            return self.array_call_native(caller, args_and_results);
+            return Self::array_call_native(me, caller, args_and_results);
         }
         vm.call(
-            self.array_call.as_non_null().cast(),
-            self.vmctx.as_non_null(),
+            me.as_ref().array_call.as_non_null().cast(),
+            me.as_ref().vmctx.as_non_null(),
             caller,
             args_and_results,
         )
     }
 
     #[inline]
     unsafe fn array_call_native(
-        &self,
+        me: NonNull<Self>,
         caller: NonNull<VMOpaqueContext>,
         args_and_results: NonNull<[ValRaw]>,
     ) -> bool {
@@ -913,11 +913,11 @@ impl VMFuncRef {
             ptr: NonNull<VMArrayCallFunction>,
         }
         let native = GetNativePointer {
-            ptr: self.array_call.as_non_null(),
+            ptr: me.as_ref().array_call.as_non_null(),
         }
         .native;
         native(
-            self.vmctx.as_non_null(),
+            me.as_ref().vmctx.as_non_null(),
             caller,
             args_and_results.cast(),
             args_and_results.len(),