Run cargo fmt

lib/api/src/import_object.rs

@@ -263,8 +263,8 @@ macro_rules! import_namespace {
 mod test {
     use super::*;
     use crate::{Global, Store, Val};
-    use wasmer_types::Type;
     use wasmer_engine::ChainableNamedResolver;
+    use wasmer_types::Type;
     use wasmer_vm::Export;
 
     #[test]

lib/api/src/lib.rs

@@ -63,10 +63,6 @@ pub use crate::types::{
 pub use crate::types::{Val as Value, ValType as Type};
 pub use crate::utils::is_wasm;
 pub use target_lexicon::{Architecture, CallingConvention, OperatingSystem, Triple, HOST};
-pub use wasmer_types::{
-    Atomically, Bytes, GlobalInit, LocalFunctionIndex, MemoryView, Pages, ValueType,
-    WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE,
-};
 #[cfg(feature = "compiler")]
 pub use wasmer_compiler::CompilerConfig;
 pub use wasmer_compiler::{
@@ -77,6 +73,10 @@ pub use wasmer_engine::{
     ChainableNamedResolver, DeserializeError, Engine, InstantiationError, LinkError, NamedResolver,
     NamedResolverChain, Resolver, RuntimeError, SerializeError,
 };
+pub use wasmer_types::{
+    Atomically, Bytes, GlobalInit, LocalFunctionIndex, MemoryView, Pages, ValueType,
+    WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE,
+};
 pub use wasmer_vm::{raise_user_trap, Export, MemoryError};
 #[cfg(feature = "wat")]
 pub use wat::parse_bytes as wat2wasm;

lib/c-api/src/instance.rs

@@ -13,10 +13,10 @@ use std::collections::HashMap;
 use std::ffi::CStr;
 use std::ptr::NonNull;
 use std::slice;
-use wasmer_types::{entity::*, ExportIndex, MemoryIndex};
 use wasmer::{
     Exports, Extern, Function, Global, ImportObject, Instance, Memory, Module, Table, Val,
 };
+use wasmer_types::{entity::*, ExportIndex, MemoryIndex};
 
 /// Opaque pointer to an Instance type plus metadata.
 ///

lib/cli/src/store.rs

@@ -201,10 +201,10 @@ impl StoreOptions {
                 use std::fmt;
                 use std::fs::File;
                 use std::io::Write;
-                use wasmer_types::entity::EntityRef;
                 use wasmer_compiler_llvm::{
                     CompiledFunctionKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
                 };
+                use wasmer_types::entity::EntityRef;
                 let mut config = LLVM::new();
                 struct Callbacks {
                     debug_dir: PathBuf,

lib/compiler-cranelift/src/compiler.rs

@@ -19,14 +19,14 @@ use cranelift_codegen::{binemit, Context};
 #[cfg(feature = "unwind")]
 use gimli::write::{Address, EhFrame, FrameTable};
 use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
-use wasmer_types::entity::{EntityRef, PrimaryMap};
-use wasmer_types::{FunctionIndex, LocalFunctionIndex, SignatureIndex};
 use wasmer_compiler::CompileError;
 use wasmer_compiler::{CallingConvention, ModuleTranslationState, Target};
 use wasmer_compiler::{
     Compilation, CompileModuleInfo, CompiledFunction, CompiledFunctionFrameInfo,
     CompiledFunctionUnwindInfo, Compiler, Dwarf, FunctionBody, FunctionBodyData, SectionIndex,
 };
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::{FunctionIndex, LocalFunctionIndex, SignatureIndex};
 
 /// A compiler that compiles a WebAssembly module with Cranelift, translating the Wasm to Cranelift IR,
 /// optimizing it and then translating to assembly.

lib/compiler-cranelift/src/dwarf.rs

@@ -1,9 +1,9 @@
 use gimli::write::{Address, EndianVec, Result, Writer};
 use gimli::{RunTimeEndian, SectionId};
-use wasmer_types::entity::EntityRef;
-use wasmer_types::LocalFunctionIndex;
 use wasmer_compiler::{CustomSection, CustomSectionProtection, SectionBody};
 use wasmer_compiler::{Endianness, Relocation, RelocationKind, RelocationTarget};
+use wasmer_types::entity::EntityRef;
+use wasmer_types::LocalFunctionIndex;
 
 #[derive(Clone, Debug)]
 pub struct WriterRelocate {

lib/compiler-cranelift/src/func_environ.rs

@@ -12,10 +12,10 @@ use cranelift_codegen::ir::types::*;
 use cranelift_codegen::ir::{AbiParam, ArgumentPurpose, Function, InstBuilder, Signature};
 use cranelift_codegen::isa::TargetFrontendConfig;
 use std::convert::TryFrom;
+use wasmer_compiler::{WasmError, WasmResult};
 use wasmer_types::entity::EntityRef;
 use wasmer_types::entity::PrimaryMap;
 use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex};
-use wasmer_compiler::{WasmError, WasmResult};
 use wasmer_vm::VMBuiltinFunctionIndex;
 use wasmer_vm::VMOffsets;
 use wasmer_vm::{MemoryStyle, ModuleInfo, TableStyle};

lib/compiler-cranelift/src/sink.rs

@@ -3,9 +3,9 @@
 use crate::translator::{irlibcall_to_libcall, irreloc_to_relocationkind};
 use cranelift_codegen::binemit;
 use cranelift_codegen::ir::{self, ExternalName};
+use wasmer_compiler::{JumpTable, Relocation, RelocationTarget, SourceLoc, TrapInformation};
 use wasmer_types::entity::EntityRef;
 use wasmer_types::{FunctionIndex, LocalFunctionIndex};
-use wasmer_compiler::{JumpTable, Relocation, RelocationTarget, SourceLoc, TrapInformation};
 use wasmer_vm::{ModuleInfo, TrapCode};
 
 /// Implementation of a relocation sink that just saves all the information for later

lib/compiler-cranelift/src/trampoline/dynamic_function.rs

@@ -16,8 +16,8 @@ use std::cmp;
 use std::mem;
 
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
-use wasmer_types::FunctionType;
 use wasmer_compiler::{CompileError, FunctionBody};
+use wasmer_types::FunctionType;
 use wasmer_vm::VMOffsets;
 
 /// Create a trampoline for invoking a WebAssembly function.

lib/compiler-cranelift/src/trampoline/function_call.rs

@@ -19,8 +19,8 @@ use cranelift_codegen::Context;
 use cranelift_codegen::{binemit, ir};
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use std::mem;
-use wasmer_types::FunctionType;
 use wasmer_compiler::{CompileError, FunctionBody};
+use wasmer_types::FunctionType;
 
 /// Create a trampoline for invoking a WebAssembly function.
 pub fn make_trampoline_function_call(

lib/compiler-cranelift/src/translator/code_translator.rs

@@ -42,10 +42,10 @@ use cranelift_codegen::ir::{
 use cranelift_codegen::packed_option::ReservedValue;
 use cranelift_frontend::{FunctionBuilder, Variable};
 use std::vec::Vec;
-use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex};
 use wasmer_compiler::wasmparser::{MemoryImmediate, Operator};
 use wasmer_compiler::{to_wasm_error, WasmResult};
 use wasmer_compiler::{wasm_unsupported, ModuleTranslationState};
+use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex};
 
 // Clippy warns about "flags: _" but its important to document that the flags field is ignored
 #[cfg_attr(

lib/compiler-cranelift/src/translator/func_environ.rs

@@ -12,9 +12,9 @@ use cranelift_codegen::ir::immediates::Offset32;
 use cranelift_codegen::ir::{self, InstBuilder};
 use cranelift_codegen::isa::TargetFrontendConfig;
 use cranelift_frontend::FunctionBuilder;
-use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex};
 use wasmer_compiler::wasmparser::Operator;
 use wasmer_compiler::WasmResult;
+use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex};
 
 /// The value of a WebAssembly global variable.
 #[derive(Clone, Copy)]

lib/compiler-cranelift/src/translator/func_state.rs

@@ -13,8 +13,8 @@ use super::func_environ::{FuncEnvironment, GlobalVariable};
 use crate::{HashMap, Occupied, Vacant};
 use cranelift_codegen::ir::{self, Block, Inst, Value};
 use std::vec::Vec;
-use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex};
 use wasmer_compiler::WasmResult;
+use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex};
 
 /// Information about the presence of an associated `else` for an `if`, or the
 /// lack thereof.

lib/compiler-cranelift/src/translator/func_translator.rs

@@ -17,12 +17,12 @@ use cranelift_codegen::ir::{self, Block, InstBuilder, ValueLabel};
 use cranelift_codegen::timing;
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
 use tracing::info;
-use wasmer_types::LocalFunctionIndex;
 use wasmer_compiler::wasmparser;
 use wasmer_compiler::{
     to_wasm_error, wasm_unsupported, GenerateMiddlewareChain, MiddlewareBinaryReader,
     ModuleTranslationState, WasmResult,
 };
+use wasmer_types::LocalFunctionIndex;
 
 /// WebAssembly to Cranelift IR function translator.
 ///

lib/compiler-cranelift/src/translator/translation_utils.rs

@@ -7,12 +7,12 @@ use cranelift_codegen::binemit::Reloc;
 use cranelift_codegen::ir::{self, AbiParam};
 use cranelift_codegen::isa::TargetFrontendConfig;
 use cranelift_frontend::FunctionBuilder;
-use wasmer_types::entity::{EntityRef, SecondaryMap};
-use wasmer_types::{FunctionType, Type};
 use wasmer_compiler::wasm_unsupported;
 use wasmer_compiler::wasmparser;
 use wasmer_compiler::{JumpTable, RelocationKind};
 use wasmer_compiler::{WasmError, WasmResult};
+use wasmer_types::entity::{EntityRef, SecondaryMap};
+use wasmer_types::{FunctionType, Type};
 use wasmer_vm::libcalls::LibCall;
 
 /// Helper function translate a Function signature into Cranelift Ir

lib/compiler-llvm/src/compiler.rs

@@ -6,13 +6,13 @@ use inkwell::memory_buffer::MemoryBuffer;
 use inkwell::module::Module;
 use inkwell::targets::FileType;
 use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
-use wasmer_types::entity::{EntityRef, PrimaryMap};
-use wasmer_types::{FunctionIndex, LocalFunctionIndex, SignatureIndex};
 use wasmer_compiler::{
     Compilation, CompileError, CompileModuleInfo, Compiler, CustomSection, CustomSectionProtection,
     Dwarf, FunctionBodyData, ModuleTranslationState, RelocationTarget, SectionBody, SectionIndex,
     Symbol, SymbolRegistry, Target,
 };
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::{FunctionIndex, LocalFunctionIndex, SignatureIndex};
 
 //use std::sync::{Arc, Mutex};
 

lib/compiler-llvm/src/config.rs

@@ -8,8 +8,8 @@ use itertools::Itertools;
 use std::fmt::Debug;
 use std::sync::Arc;
 use target_lexicon::Architecture;
-use wasmer_types::{FunctionType, LocalFunctionIndex};
 use wasmer_compiler::{Compiler, CompilerConfig, FunctionMiddlewareGenerator, Target, Triple};
+use wasmer_types::{FunctionType, LocalFunctionIndex};
 
 /// The InkWell ModuleInfo type
 pub type InkwellModule<'ctx> = inkwell::module::Module<'ctx>;

lib/compiler-llvm/src/object_file.rs

@@ -1,12 +1,12 @@
 use std::collections::{HashMap, HashSet};
 use std::convert::TryFrom;
 
-use wasmer_types::entity::{PrimaryMap, SecondaryMap};
 use wasmer_compiler::{
     CompileError, CompiledFunctionFrameInfo, CustomSection, CustomSectionProtection,
     CustomSections, FunctionAddressMap, FunctionBody, InstructionAddressMap, Relocation,
     RelocationKind, RelocationTarget, SectionBody, SectionIndex, SourceLoc,
 };
+use wasmer_types::entity::{PrimaryMap, SecondaryMap};
 use wasmer_vm::libcalls::LibCall;
 
 use wasmer_types::entity::entity_impl;

lib/compiler-llvm/src/trampoline/wasm.rs

@@ -17,8 +17,8 @@ use inkwell::{
 };
 use std::cmp;
 use std::convert::TryInto;
-use wasmer_types::{FunctionType, LocalFunctionIndex};
 use wasmer_compiler::{CompileError, FunctionBody, RelocationTarget};
+use wasmer_types::{FunctionType, LocalFunctionIndex};
 
 pub struct FuncTrampoline {
     ctx: Context,

lib/compiler-llvm/src/translator/abi.rs

@@ -22,8 +22,8 @@ use inkwell::{
     },
     AddressSpace,
 };
-use wasmer_types::{FunctionType as FuncSig, Type};
 use wasmer_compiler::CompileError;
+use wasmer_types::{FunctionType as FuncSig, Type};
 
 // Given a function definition, retrieve the parameter that is the vmctx pointer.
 pub fn get_vmctx_ptr_param<'ctx>(func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {

lib/compiler-llvm/src/translator/code.rs

@@ -24,16 +24,16 @@ use smallvec::SmallVec;
 
 use crate::config::{CompiledFunctionKind, LLVM};
 use crate::object_file::{load_object_file, CompiledFunction};
-use wasmer_types::entity::PrimaryMap;
-use wasmer_types::{
-    FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, SignatureIndex,
-    TableIndex, Type,
-};
 use wasmer_compiler::wasmparser::{MemoryImmediate, Operator};
 use wasmer_compiler::{
     to_wasm_error, wptype_to_type, CompileError, FunctionBodyData, GenerateMiddlewareChain,
     MiddlewareBinaryReader, ModuleTranslationState, RelocationTarget, Symbol, SymbolRegistry,
 };
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::{
+    FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, SignatureIndex,
+    TableIndex, Type,
+};
 use wasmer_vm::{MemoryStyle, ModuleInfo, TableStyle};
 
 const FUNCTION_SECTION: &str = "__TEXT,wasmer_function";

lib/compiler-llvm/src/translator/intrinsics.rs

@@ -20,12 +20,12 @@ use inkwell::{
     AddressSpace,
 };
 use std::collections::{hash_map::Entry, HashMap};
+use wasmer_compiler::CompileError;
 use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::{
     FunctionIndex, FunctionType as FuncType, GlobalIndex, LocalFunctionIndex, MemoryIndex,
     Mutability, SignatureIndex, TableIndex, Type,
 };
-use wasmer_compiler::CompileError;
 use wasmer_vm::ModuleInfo as WasmerCompilerModule;
 use wasmer_vm::{MemoryStyle, TrapCode, VMBuiltinFunctionIndex, VMOffsets};
 

lib/compiler-singlepass/src/codegen_x64.rs

@@ -3,14 +3,6 @@ use dynasmrt::{x64::Assembler, DynamicLabel};
 use smallvec::{smallvec, SmallVec};
 use std::collections::BTreeMap;
 use std::iter;
-use wasmer_types::{
-    entity::{EntityRef, PrimaryMap, SecondaryMap},
-    FunctionType,
-};
-use wasmer_types::{
-    FunctionIndex, GlobalIndex, LocalFunctionIndex, LocalMemoryIndex, MemoryIndex, SignatureIndex,
-    TableIndex, Type,
-};
 use wasmer_compiler::wasmparser::{
     MemoryImmediate, Operator, Type as WpType, TypeOrFuncType as WpTypeOrFuncType,
 };
@@ -19,6 +11,14 @@ use wasmer_compiler::{
     FunctionBody, Relocation, RelocationKind, RelocationTarget, SectionBody, SectionIndex,
     TrapInformation,
 };
+use wasmer_types::{
+    entity::{EntityRef, PrimaryMap, SecondaryMap},
+    FunctionType,
+};
+use wasmer_types::{
+    FunctionIndex, GlobalIndex, LocalFunctionIndex, LocalMemoryIndex, MemoryIndex, SignatureIndex,
+    TableIndex, Type,
+};
 use wasmer_vm::{MemoryStyle, ModuleInfo, TableStyle, TrapCode, VMBuiltinFunctionIndex, VMOffsets};
 
 /// The singlepass per-function code generator.

lib/compiler-singlepass/src/compiler.rs

@@ -9,8 +9,6 @@ use crate::codegen_x64::{
 use crate::config::Singlepass;
 use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
 use std::sync::Arc;
-use wasmer_types::entity::{EntityRef, PrimaryMap};
-use wasmer_types::{FunctionIndex, FunctionType, LocalFunctionIndex, MemoryIndex, TableIndex};
 use wasmer_compiler::wasmparser::BinaryReaderError;
 use wasmer_compiler::TrapInformation;
 use wasmer_compiler::{Compilation, CompileError, CompiledFunction, Compiler, SectionIndex};
@@ -19,6 +17,8 @@ use wasmer_compiler::{
     ModuleTranslationState, Target,
 };
 use wasmer_compiler::{FunctionBody, FunctionBodyData};
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::{FunctionIndex, FunctionType, LocalFunctionIndex, MemoryIndex, TableIndex};
 use wasmer_vm::{ModuleInfo, TrapCode, VMOffsets};
 
 /// A compiler that compiles a WebAssembly module with Singlepass.

lib/compiler-singlepass/src/config.rs

@@ -3,8 +3,8 @@
 
 use crate::compiler::SinglepassCompiler;
 use std::sync::Arc;
-use wasmer_types::Features;
 use wasmer_compiler::{Compiler, CompilerConfig, CpuFeature, FunctionMiddlewareGenerator, Target};
+use wasmer_types::Features;
 
 #[derive(Debug, Clone)]
 pub struct Singlepass {

lib/engine-jit/src/artifact.rs

@@ -8,11 +8,6 @@ use crate::serialize::SerializableCompilation;
 use crate::serialize::SerializableModule;
 use crate::unwind::UnwindRegistry;
 use std::sync::{Arc, Mutex};
-use wasmer_types::entity::{BoxedSlice, PrimaryMap};
-use wasmer_types::{
-    FunctionIndex, LocalFunctionIndex, MemoryIndex, OwnedDataInitializer, SignatureIndex,
-    TableIndex,
-};
 use wasmer_compiler::{CompileError, Features, Triple};
 #[cfg(feature = "compiler")]
 use wasmer_compiler::{CompileModuleInfo, ModuleEnvironment};
@@ -21,6 +16,11 @@ use wasmer_engine::{
 };
 #[cfg(feature = "compiler")]
 use wasmer_engine::{Engine, SerializableFunctionFrameInfo, Tunables};
+use wasmer_types::entity::{BoxedSlice, PrimaryMap};
+use wasmer_types::{
+    FunctionIndex, LocalFunctionIndex, MemoryIndex, OwnedDataInitializer, SignatureIndex,
+    TableIndex,
+};
 use wasmer_vm::{FunctionBodyPtr, MemoryStyle, ModuleInfo, TableStyle, VMSharedSignatureIndex};
 
 /// A compiled wasm module, ready to be instantiated.

lib/engine-jit/src/code_memory.rs

@@ -6,8 +6,8 @@ use crate::unwind::UnwindRegistry;
 use std::mem::ManuallyDrop;
 use std::sync::Arc;
 use std::{cmp, mem};
-use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_compiler::{CompiledFunctionUnwindInfo, FunctionBody, SectionBody};
+use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_vm::{FunctionBodyPtr, Mmap, VMFunctionBody};
 
 /// The optimal alignment for functions.

lib/engine-jit/src/engine.rs

@@ -4,15 +4,15 @@ use crate::unwind::UnwindRegistry;
 use crate::{CodeMemory, JITArtifact};
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
-use wasmer_types::entity::PrimaryMap;
-use wasmer_types::Features;
-use wasmer_types::{FunctionIndex, FunctionType, LocalFunctionIndex, SignatureIndex};
 #[cfg(feature = "compiler")]
 use wasmer_compiler::Compiler;
 use wasmer_compiler::{
     CompileError, CustomSection, CustomSectionProtection, FunctionBody, SectionIndex, Target,
 };
 use wasmer_engine::{Artifact, DeserializeError, Engine, EngineId, Tunables};
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::Features;
+use wasmer_types::{FunctionIndex, FunctionType, LocalFunctionIndex, SignatureIndex};
 use wasmer_vm::{
     FunctionBodyPtr, ModuleInfo, SignatureRegistry, VMFunctionBody, VMSharedSignatureIndex,
     VMTrampoline,

lib/engine-jit/src/link.rs

@@ -1,12 +1,12 @@
 //! Linking for JIT-compiled code.
 
 use std::ptr::write_unaligned;
-use wasmer_types::entity::{EntityRef, PrimaryMap};
-use wasmer_types::LocalFunctionIndex;
 use wasmer_compiler::{
     JumpTable, JumpTableOffsets, Relocation, RelocationKind, RelocationTarget, Relocations,
     SectionIndex,
 };
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::LocalFunctionIndex;
 use wasmer_vm::ModuleInfo;
 use wasmer_vm::{FunctionBodyPtr, VMFunctionBody};
 

lib/engine-jit/src/serialize.rs

@@ -1,11 +1,11 @@
 use serde::{Deserialize, Serialize};
-use wasmer_types::entity::PrimaryMap;
-use wasmer_types::{FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, SignatureIndex};
 use wasmer_compiler::{
     CompileModuleInfo, CustomSection, Dwarf, FunctionBody, JumpTableOffsets, Relocation,
     SectionIndex,
 };
 use wasmer_engine::SerializableFunctionFrameInfo;
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::{FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, SignatureIndex};
 
 // /// The serializable function data
 // #[derive(Serialize, Deserialize)]

lib/engine-native/src/artifact.rs

@@ -14,13 +14,6 @@ use std::sync::Arc;
 use tempfile::NamedTempFile;
 #[cfg(feature = "compiler")]
 use tracing::trace;
-use wasmer_types::entity::{BoxedSlice, PrimaryMap};
-#[cfg(feature = "compiler")]
-use wasmer_types::DataInitializer;
-use wasmer_types::{
-    FunctionIndex, LocalFunctionIndex, MemoryIndex, OwnedDataInitializer, SignatureIndex,
-    TableIndex,
-};
 use wasmer_compiler::{CompileError, Features, OperatingSystem, Symbol, SymbolRegistry, Triple};
 #[cfg(feature = "compiler")]
 use wasmer_compiler::{
@@ -33,6 +26,13 @@ use wasmer_engine::{
 use wasmer_engine::{Engine, Tunables};
 #[cfg(feature = "compiler")]
 use wasmer_object::{emit_compilation, emit_data, get_object_for_target};
+use wasmer_types::entity::{BoxedSlice, PrimaryMap};
+#[cfg(feature = "compiler")]
+use wasmer_types::DataInitializer;
+use wasmer_types::{
+    FunctionIndex, LocalFunctionIndex, MemoryIndex, OwnedDataInitializer, SignatureIndex,
+    TableIndex,
+};
 use wasmer_vm::{
     FunctionBodyPtr, MemoryStyle, ModuleInfo, TableStyle, VMFunctionBody, VMSharedSignatureIndex,
     VMTrampoline,

lib/engine-native/src/engine.rs

@@ -6,12 +6,12 @@ use std::path::Path;
 use std::sync::Arc;
 use std::sync::Mutex;
 #[cfg(feature = "compiler")]
-use wasmer_types::Features;
-use wasmer_types::FunctionType;
-#[cfg(feature = "compiler")]
 use wasmer_compiler::Compiler;
 use wasmer_compiler::{CompileError, Target};
 use wasmer_engine::{Artifact, DeserializeError, Engine, EngineId, Tunables};
+#[cfg(feature = "compiler")]
+use wasmer_types::Features;
+use wasmer_types::FunctionType;
 use wasmer_vm::{SignatureRegistry, VMSharedSignatureIndex, VMTrampoline};
 
 /// A WebAssembly `Native` Engine.

lib/engine-native/src/serialize.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
+use wasmer_compiler::{CompileModuleInfo, SectionIndex, Symbol, SymbolRegistry};
 use wasmer_types::entity::{EntityRef, PrimaryMap};
 use wasmer_types::{FunctionIndex, LocalFunctionIndex, OwnedDataInitializer, SignatureIndex};
-use wasmer_compiler::{CompileModuleInfo, SectionIndex, Symbol, SymbolRegistry};
 
 /// Serializable struct that represents the compiled metadata.
 #[derive(Serialize, Deserialize, Debug)]

lib/engine/src/artifact.rs

@@ -5,12 +5,12 @@ use std::any::Any;
 use std::fs;
 use std::path::Path;
 use std::sync::Arc;
+use wasmer_compiler::Features;
 use wasmer_types::entity::{BoxedSlice, PrimaryMap};
 use wasmer_types::{
     DataInitializer, FunctionIndex, LocalFunctionIndex, MemoryIndex, OwnedDataInitializer,
     SignatureIndex, TableIndex,
 };
-use wasmer_compiler::Features;
 use wasmer_vm::{
     FunctionBodyPtr, InstanceHandle, MemoryStyle, ModuleInfo, TableStyle, VMSharedSignatureIndex,
 };

lib/engine/src/engine.rs

@@ -5,8 +5,8 @@ use crate::{Artifact, DeserializeError};
 use std::path::Path;
 use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use std::sync::Arc;
-use wasmer_types::FunctionType;
 use wasmer_compiler::{CompileError, Target};
+use wasmer_types::FunctionType;
 use wasmer_vm::{VMSharedSignatureIndex, VMTrampoline};
 
 /// A unimplemented Wasmer `Engine`.

lib/engine/src/error.rs

@@ -2,8 +2,8 @@
 use crate::trap::RuntimeError;
 use std::io;
 use thiserror::Error;
-use wasmer_types::ExternType;
 use wasmer_compiler::CompileError;
+use wasmer_types::ExternType;
 
 /// The Serialize error can occur when serializing a
 /// compiled Module into a binary.

lib/engine/src/trap/frame_info.rs

@@ -14,9 +14,9 @@ use crate::serialize::SerializableFunctionFrameInfo;
 use std::cmp;
 use std::collections::BTreeMap;
 use std::sync::{Arc, RwLock};
+use wasmer_compiler::{CompiledFunctionFrameInfo, SourceLoc, TrapInformation};
 use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap};
 use wasmer_types::LocalFunctionIndex;
-use wasmer_compiler::{CompiledFunctionFrameInfo, SourceLoc, TrapInformation};
 use wasmer_vm::{FunctionBodyPtr, ModuleInfo};
 
 lazy_static::lazy_static! {

tests/lib/engine-dummy/src/artifact.rs

@@ -5,15 +5,15 @@ use crate::engine::DummyEngine;
 #[cfg(feature = "serialize")]
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
+use wasmer_compiler::CompileError;
+#[cfg(feature = "compiler")]
+use wasmer_compiler::ModuleEnvironment;
+use wasmer_engine::{Artifact, DeserializeError, Engine as _, SerializeError, Tunables};
 use wasmer_types::entity::{BoxedSlice, PrimaryMap};
 use wasmer_types::{
     Features, FunctionIndex, LocalFunctionIndex, MemoryIndex, OwnedDataInitializer, SignatureIndex,
     TableIndex,
 };
-use wasmer_compiler::CompileError;
-#[cfg(feature = "compiler")]
-use wasmer_compiler::ModuleEnvironment;
-use wasmer_engine::{Artifact, DeserializeError, Engine as _, SerializeError, Tunables};
 use wasmer_vm::{
     FunctionBodyPtr, MemoryStyle, ModuleInfo, TableStyle, VMContext, VMFunctionBody,
     VMSharedSignatureIndex,

tests/lib/engine-dummy/src/engine.rs

@@ -2,9 +2,9 @@
 
 use crate::DummyArtifact;
 use std::sync::Arc;
-use wasmer_types::FunctionType;
 use wasmer_compiler::{CompileError, Features, Target};
 use wasmer_engine::{Artifact, DeserializeError, Engine, EngineId, Tunables};
+use wasmer_types::FunctionType;
 use wasmer_vm::{
     SignatureRegistry, VMContext, VMFunctionBody, VMSharedSignatureIndex, VMTrampoline,
 };