make wasmi oracle impl compile again

Author: Robbepop

crates/fuzzing/src/oracles/diff_wasmi.rs

@@ -40,7 +40,7 @@ impl WasmiEngine {
         }
     }
 
-    fn trap_code(&self, err: &Error) -> Option<wasmi::core::TrapCode> {
+    fn trap_code(&self, err: &Error) -> Option<wasmi::TrapCode> {
         let err = err.downcast_ref::<wasmi::Error>()?;
         if let Some(code) = err.as_trap_code() {
             return Some(code);
@@ -49,12 +49,12 @@ impl WasmiEngine {
         match err.kind() {
             wasmi::errors::ErrorKind::Instantiation(
                 wasmi::errors::InstantiationError::ElementSegmentDoesNotFit { .. },
-            ) => Some(wasmi::core::TrapCode::TableOutOfBounds),
+            ) => Some(wasmi::TrapCode::TableOutOfBounds),
             wasmi::errors::ErrorKind::Memory(wasmi::errors::MemoryError::OutOfBoundsAccess) => {
-                Some(wasmi::core::TrapCode::MemoryOutOfBounds)
+                Some(wasmi::TrapCode::MemoryOutOfBounds)
             }
             wasmi::errors::ErrorKind::Table(wasmi::errors::TableError::CopyOutOfBounds) => {
-                Some(wasmi::core::TrapCode::TableOutOfBounds)
+                Some(wasmi::TrapCode::TableOutOfBounds)
             }
             _ => {
                 log::trace!("unknown wasmi error: {:?}", err.kind());
@@ -89,14 +89,14 @@ impl DiffEngine for WasmiEngine {
     fn is_non_deterministic_error(&self, err: &Error) -> bool {
         matches!(
             self.trap_code(err),
-            Some(wasmi::core::TrapCode::StackOverflow)
+            Some(wasmi::TrapCode::StackOverflow)
         )
     }
 }
 
 /// Converts `wasmi` trap code to `wasmtime` trap code.
-fn wasmi_to_wasmtime_trap_code(trap: wasmi::core::TrapCode) -> Trap {
-    use wasmi::core::TrapCode;
+fn wasmi_to_wasmtime_trap_code(trap: wasmi::TrapCode) -> Trap {
+    use wasmi::TrapCode;
     match trap {
         TrapCode::UnreachableCodeReached => Trap::UnreachableCodeReached,
         TrapCode::MemoryOutOfBounds => Trap::MemoryOutOfBounds,
@@ -174,9 +174,9 @@ impl From<&DiffValue> for wasmi::Val {
         match *v {
             DiffValue::I32(n) => WasmiValue::I32(n),
             DiffValue::I64(n) => WasmiValue::I64(n),
-            DiffValue::F32(n) => WasmiValue::F32(wasmi::core::F32::from_bits(n)),
-            DiffValue::F64(n) => WasmiValue::F64(wasmi::core::F64::from_bits(n)),
-            DiffValue::V128(n) => WasmiValue::V128(wasmi::core::V128::from(n)),
+            DiffValue::F32(n) => WasmiValue::F32(wasmi::F32::from_bits(n)),
+            DiffValue::F64(n) => WasmiValue::F64(wasmi::F64::from_bits(n)),
+            DiffValue::V128(n) => WasmiValue::V128(wasmi::V128::from(n)),
             DiffValue::FuncRef { null } => {
                 assert!(null);
                 WasmiValue::default(wasmi::ValType::FuncRef)