Fixed code smell on Engine/CompiledModule

lib/api/src/module.rs

@@ -208,7 +208,10 @@ impl Module {
             // of this steps traps, we still need to keep the instance alive
             // as some of the Instance elements may have placed in other
             // instance tables.
-            self.compiled.finish_instantiation(&instance_handle)?;
+            self.store
+                .engine()
+                .finish_instantiation(self.compiled.borrow(), &instance_handle)?;
+
             Ok(instance_handle)
         }
     }

lib/engine-jit/src/engine.rs

@@ -130,6 +130,16 @@ impl Engine for JITEngine {
         unsafe { compiled_module.instantiate(&self, resolver, Box::new(())) }
     }
 
+    /// Finish the instantiation of a WebAssembly module
+    unsafe fn finish_instantiation(
+        &self,
+        compiled_module: &dyn BaseCompiledModule,
+        handle: &InstanceHandle,
+    ) -> Result<(), InstantiationError> {
+        let compiled_module = compiled_module.downcast_ref::<CompiledModule>().unwrap();
+        unsafe { compiled_module.finish_instantiation(&handle) }
+    }
+
     /// Serializes a WebAssembly module
     fn serialize(
         &self,

lib/engine-jit/src/module.rs

@@ -246,6 +246,21 @@ impl CompiledModule {
         .map_err(|trap| InstantiationError::Start(RuntimeError::from_trap(trap)))
     }
 
+    /// Finishes the instantiation of a just created `InstanceHandle`.
+    ///
+    /// # Unsafety
+    ///
+    /// See `InstanceHandle::finish_instantiation`
+    pub unsafe fn finish_instantiation(
+        &self,
+        handle: &InstanceHandle,
+    ) -> Result<(), InstantiationError> {
+        let is_bulk_memory: bool = self.serializable.features.bulk_memory;
+        handle
+            .finish_instantiation(is_bulk_memory, &self.data_initializers())
+            .map_err(|trap| InstantiationError::Start(RuntimeError::from_trap(trap)))
+    }
+
     /// Returns data initializers to pass to `InstanceHandle::initialize`
     pub fn data_initializers(&self) -> Vec<DataInitializer<'_>> {
         self.serializable
@@ -276,16 +291,6 @@ impl CompiledModule {
 }
 
 impl BaseCompiledModule for CompiledModule {
-    unsafe fn finish_instantiation(
-        &self,
-        handle: &InstanceHandle,
-    ) -> Result<(), InstantiationError> {
-        let is_bulk_memory: bool = self.serializable.features.bulk_memory;
-        handle
-            .finish_instantiation(is_bulk_memory, &self.data_initializers())
-            .map_err(|trap| InstantiationError::Start(RuntimeError::from_trap(trap)))
-    }
-
     fn module(&self) -> &Module {
         &self.serializable.module
     }

lib/engine/src/engine.rs

@@ -38,6 +38,13 @@ pub trait Engine {
         resolver: &dyn Resolver,
     ) -> Result<InstanceHandle, InstantiationError>;
 
+    /// Finish the instantiation of a WebAssembly module
+    unsafe fn finish_instantiation(
+        &self,
+        compiled_module: &dyn CompiledModule,
+        handle: &InstanceHandle,
+    ) -> Result<(), InstantiationError>;
+
     /// Serializes a WebAssembly module
     fn serialize(&self, compiled_module: &dyn CompiledModule) -> Result<Vec<u8>, SerializeError>;
 

lib/engine/src/module.rs

@@ -8,21 +8,11 @@ use downcast_rs::{impl_downcast, Downcast};
 /// The `CompiledModule` trait is used by engine implementors, such
 /// as a JIT or Native execution.
 pub trait CompiledModule: Downcast {
-    /// Finish instantiation of a `InstanceHandle`
+    /// Return a pointer to a module.
-    ///
-    /// # Unsafety
-    ///
-    /// See `InstanceHandle::finish_instantiation`
-    unsafe fn finish_instantiation(
-        &self,
-        handle: &InstanceHandle,
-    ) -> Result<(), InstantiationError>;
-
-    /// Return a reference-counting pointer to a module.
     fn module(&self) -> &Module;
 
-    /// Return a reference-counting pointer to a module.
+    /// Return a mutable pointer to a module.
     fn module_mut(&mut self) -> &mut Module;
 }
 
-impl_downcast!(CompiledModule); // `sync` => also produce `Arc` downcasts.
+impl_downcast!(CompiledModule);