Rename UniversalArtifact to Artifact

CHANGELOG.md

@@ -15,6 +15,7 @@ Looking for changes that affect our C API? See the [C API Changelog](lib/c-api/C
 - [#2946](https://github.com/wasmerio/wasmer/pull/2946) Remove dylib,staticlib engines in favor of a single Universal engine
 - [#2949](https://github.com/wasmerio/wasmer/pull/2949) Switch back to using custom LLVM builds on CI
 - #2892 Renamed `get_native_function` to `get_typed_function`, marked former as deprecated.
+- [#2869](https://github.com/wasmerio/wasmer/pull/2869) Removed Artifact, Engine traits. Renamed UniversalArtifact to Artifact, and UniversalEngine to Engine.
 
 ### Fixed
 - [#2963](https://github.com/wasmerio/wasmer/pull/2963) Remove accidental dependency on libwayland and libxcb in ClI

docs/migration_to_3.0.0.md

@@ -138,7 +138,7 @@ let wasm_bytes = wat2wasm(
 let compiler_config = Cranelift::default();
 let mut store = Store::new(&compiler_config);
 let module = Module::new(&store, wasm_bytes)?;
-let instance = Instance::new(&module, &imports! {})?;
+let instance = Instance::new(&mut store, &module, &imports! {})?;
 ```
 
 [examples]: https://docs.wasmer.io/integrations/examples

lib/api/src/sys/mod.rs

@@ -94,7 +94,7 @@ pub use wasmer_compiler_cranelift::{Cranelift, CraneliftOptLevel};
 pub use wasmer_compiler_llvm::{LLVMOptLevel, LLVM};
 
 #[cfg(feature = "universal")]
-pub use wasmer_compiler::{Engine, Universal, UniversalArtifact};
+pub use wasmer_compiler::{Artifact, Engine, Universal};
 
 /// Version number of this crate.
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");

lib/api/src/sys/module.rs

@@ -6,8 +6,8 @@ use std::io;
 use std::path::Path;
 use std::sync::Arc;
 use thiserror::Error;
+use wasmer_compiler::Artifact;
 use wasmer_compiler::ArtifactCreate;
-use wasmer_compiler::UniversalArtifact;
 #[cfg(feature = "wat")]
 use wasmer_types::WasmError;
 use wasmer_types::{
@@ -50,7 +50,7 @@ pub struct Module {
     //
     // In the future, this code should be refactored to properly describe the
     // ownership of the code and its metadata.
-    artifact: Arc<UniversalArtifact>,
+    artifact: Arc<Artifact>,
     module_info: Arc<ModuleInfo>,
 }
 
@@ -281,7 +281,7 @@ impl Module {
         Ok(Self::from_artifact(artifact))
     }
 
-    fn from_artifact(artifact: Arc<UniversalArtifact>) -> Self {
+    fn from_artifact(artifact: Arc<Artifact>) -> Self {
         Self {
             module_info: Arc::new(artifact.create_module_info()),
             artifact,
@@ -456,7 +456,7 @@ impl Module {
     /// this functionality is required for some core functionality though, like
     /// the object file engine.
     #[doc(hidden)]
-    pub fn artifact(&self) -> &Arc<UniversalArtifact> {
+    pub fn artifact(&self) -> &Arc<Artifact> {
         &self.artifact
     }
 }

lib/cli-compiler/src/commands/compile.rs

@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 use std::path::{Path, PathBuf};
 use structopt::StructOpt;
 use wasmer_compiler::ModuleEnvironment;
-use wasmer_compiler::{ArtifactCreate, UniversalArtifactBuild};
+use wasmer_compiler::{ArtifactBuild, ArtifactCreate};
 use wasmer_types::entity::PrimaryMap;
 use wasmer_types::{
     CompileError, CpuFeature, MemoryIndex, MemoryStyle, TableIndex, TableStyle, Target, Triple,
@@ -39,10 +39,6 @@ impl Compile {
             .context(format!("failed to compile `{}`", self.path.display()))
     }
 
-    pub(crate) fn get_recommend_extension(target_triple: &Triple) -> Result<&'static str> {
-        Ok(wasmer_compiler::UniversalArtifactBuild::get_default_extension(target_triple))
-    }
-
     fn inner_execute(&self) -> Result<()> {
         let target = self
             .target_triple
@@ -65,7 +61,9 @@ impl Compile {
             .file_stem()
             .map(|osstr| osstr.to_string_lossy().to_string())
             .unwrap_or_default();
-        let recommended_extension = Self::get_recommend_extension(target.triple())?;
+        // `.wasmu` is the default extension for all the triples. It
+        // stands for “Wasm Universal”.
+        let recommended_extension = "wasmu";
         match self.output.extension() {
             Some(ext) => {
                 if ext != recommended_extension {
@@ -97,7 +95,7 @@ impl Compile {
             .values()
             .map(|table_type| tunables.table_style(table_type))
             .collect();
-        let artifact = UniversalArtifactBuild::new(
+        let artifact = ArtifactBuild::new(
             &mut engine,
             &wasm_bytes,
             &target,

lib/cli/src/commands/compile.rs

@@ -56,8 +56,8 @@ impl Compile {
             .file_stem()
             .map(|osstr| osstr.to_string_lossy().to_string())
             .unwrap_or_default();
-        let recommended_extension =
-            wasmer_compiler::UniversalArtifact::get_default_extension(target.triple());
+        // wasmu stands for "WASM Universal"
+        let recommended_extension = "wasmu";
         match self.output.extension() {
             Some(ext) => {
                 if ext != recommended_extension {

lib/cli/src/commands/run.rs

@@ -235,7 +235,7 @@ impl Run {
 
     fn get_store_module(&self) -> Result<(Store, Module)> {
         let contents = std::fs::read(self.path.clone())?;
-        if wasmer_compiler::UniversalArtifact::is_deserializable(&contents) {
+        if wasmer_compiler::Artifact::is_deserializable(&contents) {
             let engine = wasmer_compiler::Universal::headless().engine();
             let store = Store::new_with_engine(&engine);
             let module = unsafe { Module::deserialize_from_file(&store, &self.path)? };
@@ -308,8 +308,7 @@ impl Run {
         cache_dir_root.push(compiler_type.to_string());
         let mut cache = FileSystemCache::new(cache_dir_root)?;
 
-        let extension =
-            wasmer_compiler::UniversalArtifact::get_default_extension(&Triple::host()).to_string();
+        let extension = "wasmu";
         cache.set_cache_extension(Some(extension));
         Ok(cache)
     }

lib/compiler/src/engine/universal/artifact.rs

@@ -1,13 +1,13 @@
-//! Define `UniversalArtifact`, based on `UniversalArtifactBuild`
+//! Define `Artifact`, based on `ArtifactBuild`
 //! to allow compiling and instantiating to be done as separate steps.
 
 use super::engine::{Engine, EngineInner};
 use crate::engine::universal::link::link_module;
+use crate::ArtifactBuild;
 use crate::ArtifactCreate;
 use crate::Features;
 #[cfg(feature = "universal_engine")]
 use crate::ModuleEnvironment;
-use crate::UniversalArtifactBuild;
 use crate::{
     register_frame_info, resolve_imports, FunctionExtent, GlobalFrameInfoRegistration,
     InstantiationError, MetadataHeader, RuntimeError, Tunables,
@@ -19,14 +19,14 @@ use wasmer_types::entity::{BoxedSlice, PrimaryMap};
 use wasmer_types::{
     CompileError, CpuFeature, DataInitializer, DeserializeError, FunctionIndex, LocalFunctionIndex,
     MemoryIndex, ModuleInfo, OwnedDataInitializer, SerializableModule, SerializeError,
-    SignatureIndex, TableIndex, Triple,
+    SignatureIndex, TableIndex,
 };
 use wasmer_vm::{FunctionBodyPtr, MemoryStyle, TableStyle, VMSharedSignatureIndex, VMTrampoline};
 use wasmer_vm::{InstanceAllocator, InstanceHandle, StoreObjects, TrapHandlerFn, VMExtern};
 
 /// A compiled wasm module, ready to be instantiated.
-pub struct UniversalArtifact {
-    artifact: UniversalArtifactBuild,
+pub struct Artifact {
+    artifact: ArtifactBuild,
     finished_functions: BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>,
     finished_function_call_trampolines: BoxedSlice<SignatureIndex, VMTrampoline>,
     finished_dynamic_function_trampolines: BoxedSlice<FunctionIndex, FunctionBodyPtr>,
@@ -35,8 +35,8 @@ pub struct UniversalArtifact {
     finished_function_lengths: BoxedSlice<LocalFunctionIndex, usize>,
 }
 
-impl UniversalArtifact {
-    /// Compile a data buffer into a `UniversalArtifactBuild`, which may then be instantiated.
+impl Artifact {
+    /// Compile a data buffer into a `ArtifactBuild`, which may then be instantiated.
     #[cfg(feature = "universal_engine")]
     pub fn new(
         engine: &Engine,
@@ -58,7 +58,7 @@ impl UniversalArtifact {
             .map(|table_type| tunables.table_style(table_type))
             .collect();
 
-        let artifact = UniversalArtifactBuild::new(
+        let artifact = ArtifactBuild::new(
             inner_engine.builder_mut(),
             data,
             engine.target(),
@@ -69,38 +69,38 @@ impl UniversalArtifact {
         Self::from_parts(&mut inner_engine, artifact)
     }
 
-    /// Compile a data buffer into a `UniversalArtifactBuild`, which may then be instantiated.
+    /// Compile a data buffer into a `ArtifactBuild`, which may then be instantiated.
     #[cfg(not(feature = "universal_engine"))]
     pub fn new(_engine: &Engine, _data: &[u8]) -> Result<Self, CompileError> {
         Err(CompileError::Codegen(
             "Compilation is not enabled in the engine".to_string(),
         ))
     }
 
-    /// Deserialize a UniversalArtifactBuild
+    /// Deserialize a ArtifactBuild
     ///
     /// # Safety
     /// This function is unsafe because rkyv reads directly without validating
     /// the data.
     pub unsafe fn deserialize(engine: &Engine, bytes: &[u8]) -> Result<Self, DeserializeError> {
-        if !UniversalArtifactBuild::is_deserializable(bytes) {
+        if !ArtifactBuild::is_deserializable(bytes) {
             return Err(DeserializeError::Incompatible(
                 "The provided bytes are not wasmer-universal".to_string(),
             ));
         }
-        let bytes = &bytes[UniversalArtifactBuild::MAGIC_HEADER.len()..];
+        let bytes = &bytes[ArtifactBuild::MAGIC_HEADER.len()..];
         let metadata_len = MetadataHeader::parse(bytes)?;
         let metadata_slice: &[u8] = &bytes[MetadataHeader::LEN..][..metadata_len];
         let serializable = SerializableModule::deserialize(metadata_slice)?;
-        let artifact = UniversalArtifactBuild::from_serializable(serializable);
+        let artifact = ArtifactBuild::from_serializable(serializable);
         let mut inner_engine = engine.inner_mut();
         Self::from_parts(&mut inner_engine, artifact).map_err(DeserializeError::Compiler)
     }
 
-    /// Construct a `UniversalArtifactBuild` from component parts.
+    /// Construct a `ArtifactBuild` from component parts.
     pub fn from_parts(
         engine_inner: &mut EngineInner,
-        artifact: UniversalArtifactBuild,
+        artifact: ArtifactBuild,
     ) -> Result<Self, CompileError> {
         let module_info = artifact.create_module_info();
         let (
@@ -180,17 +180,14 @@ impl UniversalArtifact {
             finished_function_lengths,
         })
     }
-    /// Get the default extension when serializing this artifact
-    pub fn get_default_extension(triple: &Triple) -> &'static str {
-        UniversalArtifactBuild::get_default_extension(triple)
-    }
-    /// Check if the provided bytes look like a serialized `UniversalArtifactBuild`.
+
+    /// Check if the provided bytes look like a serialized `ArtifactBuild`.
     pub fn is_deserializable(bytes: &[u8]) -> bool {
-        UniversalArtifactBuild::is_deserializable(bytes)
+        ArtifactBuild::is_deserializable(bytes)
     }
 }
 
-impl ArtifactCreate for UniversalArtifact {
+impl ArtifactCreate for Artifact {
     fn create_module_info(&self) -> ModuleInfo {
         self.artifact.create_module_info()
     }
@@ -220,7 +217,7 @@ impl ArtifactCreate for UniversalArtifact {
     }
 }
 
-impl UniversalArtifact {
+impl Artifact {
     /// Register thie `Artifact` stack frame information into the global scope.
     ///
     /// This is required to ensure that any traps can be properly symbolicated.

lib/compiler/src/engine/universal/engine.rs

@@ -3,7 +3,7 @@
 #[cfg(feature = "universal_engine")]
 use crate::Compiler;
 use crate::EngineBuilder;
-use crate::{CodeMemory, UniversalArtifact};
+use crate::{Artifact, CodeMemory};
 use crate::{FunctionExtent, Tunables};
 use memmap2::Mmap;
 use std::path::Path;
@@ -106,8 +106,8 @@ impl Engine {
         &self,
         binary: &[u8],
         tunables: &dyn Tunables,
-    ) -> Result<Arc<UniversalArtifact>, CompileError> {
-        Ok(Arc::new(UniversalArtifact::new(self, binary, tunables)?))
+    ) -> Result<Arc<Artifact>, CompileError> {
+        Ok(Arc::new(Artifact::new(self, binary, tunables)?))
     }
 
     /// Compile a WebAssembly binary
@@ -116,7 +116,7 @@ impl Engine {
         &self,
         _binary: &[u8],
         _tunables: &dyn Tunables,
-    ) -> Result<Arc<UniversalArtifact>, CompileError> {
+    ) -> Result<Arc<Artifact>, CompileError> {
         Err(CompileError::Codegen(
             "The Engine is operating in headless mode, so it can not compile Modules.".to_string(),
         ))
@@ -127,11 +127,8 @@ impl Engine {
     /// # Safety
     ///
     /// The serialized content must represent a serialized WebAssembly module.
-    pub unsafe fn deserialize(
-        &self,
-        bytes: &[u8],
-    ) -> Result<Arc<UniversalArtifact>, DeserializeError> {
-        Ok(Arc::new(UniversalArtifact::deserialize(self, bytes)?))
+    pub unsafe fn deserialize(&self, bytes: &[u8]) -> Result<Arc<Artifact>, DeserializeError> {
+        Ok(Arc::new(Artifact::deserialize(self, bytes)?))
     }
 
     /// Deserializes a WebAssembly module from a path
@@ -142,7 +139,7 @@ impl Engine {
     pub unsafe fn deserialize_from_file(
         &self,
         file_ref: &Path,
-    ) -> Result<Arc<UniversalArtifact>, DeserializeError> {
+    ) -> Result<Arc<Artifact>, DeserializeError> {
         let file = std::fs::File::open(file_ref)?;
         let mmap = Mmap::map(&file)?;
         self.deserialize(&mmap)

lib/compiler/src/engine/universal/mod.rs

@@ -11,7 +11,7 @@ mod engine;
 mod link;
 mod unwind;
 
-pub use self::artifact::UniversalArtifact;
+pub use self::artifact::Artifact;
 pub use self::builder::Universal;
 pub use self::code_memory::CodeMemory;
 pub use self::engine::Engine;