Merge #3047

3047: Improved EngineBuilder API r=epilys a=syrusakbary This PR is a followup from #3046. It basically allows Store being created from anything that can get into `Into<Engine>`, which simplifies greatly the API. It also improves the `EngineBuilder` API, by simplify the `::new` method and making the modifier chain usable when doing `set_target`, `set_features`. The PR also deprecates `Store::new_with_engine` in favor of `Store::new` since `Store::new` can now take `EngineBuilder`, `Engine` and `Box<dyn CompilerConfig>`. Co-authored-by: Syrus Akbary <[email protected]>
wasmerio · Jul 28, 2022 · 5e26bc4 · 5e26bc4
2 parents b2dc07e + 4384ddf
commit 5e26bc4
Show file tree

Hide file tree

Showing 57 changed files with 191 additions and 263 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,6 +9,7 @@ Looking for changes that affect our C API? See the [C API Changelog](lib/c-api/C
 ## **Unreleased**
 
 ### Changed
+- [#3047](https://github.com/wasmerio/wasmer/pull/3047) `Store::new` now takes an `impl Into<Engine>`.
 - [#3017](https://github.com/wasmerio/wasmer/pull/3017) Fix typo in README.md
 - [#3008](https://github.com/wasmerio/wasmer/pull/3008) Add a new CI check that uses cargo public-api to track changes in the API between master and the last deployed version on crates.io
 - [#3003](https://github.com/wasmerio/wasmer/pull/3003) Remove RuntimeError::raise from public API

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/benches/static_and_dynamic_functions.rs b/benches/static_and_dynamic_functions.rs
@@ -149,71 +149,39 @@ pub fn run_basic_dynamic_function(store: &Store, compiler_name: &str, c: &mut Cr
 fn run_static_benchmarks(_c: &mut Criterion) {
     #[cfg(feature = "llvm")]
     {
-        let mut store = Store::new_with_engine(
-            &EngineBuilder::new(Some(wasmer_compiler_llvm::LLVM::new()), None, None).engine(),
-        );
+        let mut store = Store::new(wasmer_compiler_llvm::LLVM::new());
         run_basic_static_function(&store, "llvm", c);
     }
 
     #[cfg(feature = "cranelift")]
     {
-        let mut store = Store::new_with_engine(
-            &EngineBuilder::new(
-                Some(wasmer_compiler_cranelift::Cranelift::new()),
-                None,
-                None,
-            )
-            .engine(),
-        );
+        let mut store = Store::new(wasmer_compiler_cranelift::Cranelift::new());
         run_basic_static_function(&store, "cranelift", c);
     }
 
     #[cfg(feature = "singlepass")]
     {
-        let mut store = Store::new_with_engine(
-            &EngineBuilder::new(
-                Some(wasmer_compiler_singlepass::Singlepass::new()),
-                None,
-                None,
-            )
-            .engine(),
-        );
+        let mut store = Store::new(wasmer_compiler_singlepass::Singlepass::new());
         run_basic_static_function(&store, "singlepass", c);
     }
 }
 
 fn run_dynamic_benchmarks(_c: &mut Criterion) {
     #[cfg(feature = "llvm")]
     {
-        let mut store = Store::new_with_engine(
-            &EngineBuilder::new(Some(wasmer_compiler_llvm::LLVM::new()), None, None).engine(),
-        );
+        let mut store = Store::new(wasmer_compiler_llvm::LLVM::new());
         run_basic_dynamic_function(&store, "llvm", c);
     }
 
     #[cfg(feature = "cranelift")]
     {
-        let mut store = Store::new_with_engine(
-            &EngineBuilder::new(
-                Some(wasmer_compiler_cranelift::Cranelift::new()),
-                None,
-                None,
-            )
-            .engine(),
-        );
+        let mut store = Store::new(wasmer_compiler_cranelift::Cranelift::new());
         run_basic_dynamic_function(&store, "cranelift", c);
     }
 
     #[cfg(feature = "singlepass")]
     {
-        let mut store = Store::new_with_engine(
-            &EngineBuilder::new(
-                Some(wasmer_compiler_singlepass::Singlepass::new()),
-                None,
-                None,
-            )
-            .engine(),
-        );
+        let mut store = Store::new(wasmer_compiler_singlepass::Singlepass::new());
         run_basic_dynamic_function(&store, "singlepass", c);
     }
 }

diff --git a/docs/migration_to_3.0.0.md b/docs/migration_to_3.0.0.md
@@ -145,12 +145,27 @@ let wasm_bytes = wat2wasm(
     "..".as_bytes(),
 )?;
 
-let compiler_config = Cranelift::default();
-let mut store = Store::new(&compiler_config);
+let compiler = Cranelift::default();
+let mut store = Store::new(compiler);
 let module = Module::new(&store, wasm_bytes)?;
 let instance = Instance::new(&mut store, &module, &imports! {})?;
 ```
 
+#### Advanced configuration
+
+The previous ability to define target and features remains in a new `EngineBuilder` interface:
+
+```rust
+let compiler = Cranelift::default();
+
+let mut features = Features::new();
+// Enable the multi-value feature.
+features.multi_value(true);
+
+let engine = EngineBuilder::new(compiler).set_features(Some(features));
+let store = Store::new(engine);
+```
+
 [examples]: https://docs.wasmer.io/integrations/examples
 [wasmer]: https://crates.io/crates/wasmer
 [wasmer-wasi]: https://crates.io/crates/wasmer-wasi

diff --git a/examples/compiler_cranelift.rs b/examples/compiler_cranelift.rs
@@ -11,7 +11,6 @@
 //! Ready?
 
 use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
-use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -33,7 +32,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let compiler = Cranelift::default();
 
     // Create the store
-    let mut store = Store::new_with_engine(&EngineBuilder::new(compiler, None, None).engine());
+    let mut store = Store::new(compiler);
 
     println!("Compiling module...");
     // Let's compile the Wasm module.

diff --git a/examples/compiler_llvm.rs b/examples/compiler_llvm.rs
@@ -11,7 +11,6 @@
 //! Ready?
 
 use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
-use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_llvm::LLVM;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -33,7 +32,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let compiler = LLVM::default();
 
     // Create the store
-    let mut store = Store::new_with_engine(&EngineBuilder::new(compiler, None, None).engine());
+    let mut store = Store::new(compiler);
 
     println!("Compiling module...");
     // Let's compile the Wasm module.

diff --git a/examples/compiler_singlepass.rs b/examples/compiler_singlepass.rs
@@ -11,7 +11,6 @@
 //! Ready?
 
 use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
-use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_singlepass::Singlepass;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -33,7 +32,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let compiler = Singlepass::default();
 
     // Create the store
-    let mut store = Store::new_with_engine(&EngineBuilder::new(compiler, None, None).engine());
+    let mut store = Store::new(compiler);
 
     println!("Compiling module...");
     // Let's compile the Wasm module.

diff --git a/examples/early_exit.rs b/examples/early_exit.rs
@@ -20,7 +20,6 @@ use wasmer::{
     imports, wat2wasm, Function, FunctionEnv, FunctionEnvMut, Instance, Module, Store,
     TypedFunction,
 };
-use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_cranelift::Cranelift;
 
 // First we need to create an error type that we'll use to signal the end of execution.
@@ -58,8 +57,7 @@ fn main() -> anyhow::Result<()> {
     // Note that we don't need to specify the engine/compiler if we want to use
     // the default provided by Wasmer.
     // You can use `Store::default()` for that.
-    let mut store =
-        Store::new_with_engine(&EngineBuilder::new(Cranelift::default(), None, None).engine());
+    let mut store = Store::new(Cranelift::default());
     let env = FunctionEnv::new(&mut store, ());
 
     println!("Compiling module...");

diff --git a/examples/engine.rs b/examples/engine.rs
@@ -18,8 +18,7 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
-use wasmer_compiler::EngineBuilder;
+use wasmer::{imports, wat2wasm, EngineBuilder, Instance, Module, Store, Value};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -49,10 +48,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     //
     // In this case, the engine is `wasmer_compiler` which roughly
     // means that the executable code will live in memory.
-    let engine = EngineBuilder::new(compiler_config, None, None).engine();
+    let engine = EngineBuilder::new(compiler_config);
 
     // Create a store, that holds the engine.
-    let mut store = Store::new_with_engine(&engine);
+    let mut store = Store::new(engine);
 
     println!("Compiling module...");
     // Here we go.

diff --git a/examples/engine_cross_compilation.rs b/examples/engine_cross_compilation.rs
@@ -19,8 +19,7 @@
 //! Ready?
 
 use std::str::FromStr;
-use wasmer::{wat2wasm, Module, RuntimeError, Store};
-use wasmer_compiler::EngineBuilder;
+use wasmer::{wat2wasm, EngineBuilder, Module, RuntimeError, Store};
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_types::{CpuFeature, Target, Triple};
 
@@ -70,10 +69,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // That's where we specify the target for the compiler.
     //
     // Use the Universal engine.
-    let mut engine = EngineBuilder::new(compiler_config, Some(target), None).engine();
+    let mut engine = EngineBuilder::new(compiler_config).set_target(Some(target));
 
     // Create a store, that holds the engine.
-    let mut store = Store::new_with_engine(&engine);
+    let mut store = Store::new(engine);
 
     println!("Compiling module...");
     // Let's compile the Wasm module.

diff --git a/examples/engine_dylib.rs b/examples/engine_dylib.rs
@@ -52,10 +52,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         //
         // In this case, the engine is `wasmer_engine_dylib` which means
         // that a shared object is going to be generated.
-        let engine = Dylib::new(compiler_config).engine();
+        let engine = Dylib::new(compiler_config);
 
         // Create a store, that holds the engine.
-        let mut store = Store::new_with_engine(&engine);
+        let mut store = Store::new(engine);
 
         println!("Compiling module...");
         // Here we go.

diff --git a/examples/engine_headless.rs b/examples/engine_headless.rs
@@ -45,14 +45,7 @@
 //! Ready?
 
 use tempfile::NamedTempFile;
-use wasmer::imports;
-use wasmer::wat2wasm;
-use wasmer::FunctionEnv;
-use wasmer::Instance;
-use wasmer::Module;
-use wasmer::Store;
-use wasmer::Value;
-use wasmer_compiler::EngineBuilder;
+use wasmer::{imports, wat2wasm, EngineBuilder, FunctionEnv, Instance, Module, Store, Value};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -78,14 +71,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         // In this situation, the compiler is
         // `wasmer_compiler_cranelift`. The compiler is responsible to
         // compile the Wasm module into executable code.
-        let compiler_config = Cranelift::default();
-
-        println!("Creating univesral engine...");
-        // Define the engine that will drive everything.
-        let engine = EngineBuilder::new(compiler_config, None, None).engine();
+        let compiler = Cranelift::default();
 
         // Create a store, that holds the engine.
-        let mut store = Store::new_with_engine(&engine);
+        let mut store = Store::new(compiler);
 
         println!("Compiling module...");
         // Let's compile the Wasm module.
@@ -105,8 +94,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     {
         println!("Creating headless Universal engine...");
         // We create a headless Universal engine.
-        let engine = EngineBuilder::headless().engine();
-        let mut store = Store::new_with_engine(&engine);
+        let engine = EngineBuilder::headless();
+        let mut store = Store::new(engine);
         let mut env = FunctionEnv::new(&mut store, ());
 
         println!("Deserializing module...");

diff --git a/examples/errors.rs b/examples/errors.rs
@@ -14,7 +14,6 @@
 //! Ready?
 
 use wasmer::{imports, wat2wasm, FunctionEnv, Instance, Module, Store, TypedFunction};
-use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -39,8 +38,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Note that we don't need to specify the engine/compiler if we want to use
     // the default provided by Wasmer.
     // You can use `Store::default()` for that.
-    let mut store =
-        Store::new_with_engine(&EngineBuilder::new(Cranelift::default(), None, None).engine());
+    let mut store = Store::new(Cranelift::default());
     let mut env = FunctionEnv::new(&mut store, ());
 
     println!("Compiling module...");

diff --git a/examples/exports_function.rs b/examples/exports_function.rs
@@ -18,7 +18,6 @@
 //! Ready?
 
 use wasmer::{imports, wat2wasm, FunctionEnv, Instance, Module, Store, TypedFunction, Value};
-use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -40,8 +39,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Note that we don't need to specify the engine/compiler if we want to use
     // the default provided by Wasmer.
     // You can use `Store::default()` for that.
-    let mut store =
-        Store::new_with_engine(&EngineBuilder::new(Cranelift::default(), None, None).engine());
+    let mut store = Store::new(Cranelift::default());
     let mut env = FunctionEnv::new(&mut store, ());
 
     println!("Compiling module...");

diff --git a/examples/exports_global.rs b/examples/exports_global.rs
@@ -18,7 +18,6 @@
 use wasmer::{
     imports, wat2wasm, FunctionEnv, Instance, Module, Mutability, Store, Type, TypedFunction, Value,
 };
-use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -40,8 +39,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Note that we don't need to specify the engine/compiler if we want to use
     // the default provided by Wasmer.
     // You can use `Store::default()` for that.
-    let mut store =
-        Store::new_with_engine(&EngineBuilder::new(Cranelift::default(), None, None).engine());
+    let mut store = Store::new(Cranelift::default());
     let mut env = FunctionEnv::new(&mut store, ());
 
     println!("Compiling module...");

diff --git a/examples/exports_memory.rs b/examples/exports_memory.rs
@@ -12,7 +12,6 @@
 //! Ready?
 
 use wasmer::{imports, wat2wasm, FunctionEnv, Instance, Module, Store, TypedFunction, WasmPtr};
-use wasmer_compiler::EngineBuilder;
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -37,8 +36,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Note that we don't need to specify the engine/compiler if we want to use
     // the default provided by Wasmer.
     // You can use `Store::default()` for that.
-    let mut store =
-        Store::new_with_engine(&EngineBuilder::new(Cranelift::default(), None, None).engine());
+    let mut store = Store::new(Cranelift::default());
     let mut env = FunctionEnv::new(&mut store, ());
 
     println!("Compiling module...");

diff --git a/examples/features.rs b/examples/features.rs
@@ -10,8 +10,9 @@
 //!
 //! Ready?
 
-use wasmer::{imports, wat2wasm, Features, FunctionEnv, Instance, Module, Store, Value};
-use wasmer_compiler::EngineBuilder;
+use wasmer::{
+    imports, wat2wasm, EngineBuilder, Features, FunctionEnv, Instance, Module, Store, Value,
+};
 use wasmer_compiler_cranelift::Cranelift;
 
 fn main() -> anyhow::Result<()> {
@@ -36,10 +37,10 @@ fn main() -> anyhow::Result<()> {
     features.multi_value(true);
 
     // Set up the engine. That's where we define the features!
-    let engine = EngineBuilder::new(compiler, None, Some(features));
+    let engine = EngineBuilder::new(compiler).set_features(Some(features));
 
     // Now, let's define the store, and compile the module.
-    let mut store = Store::new_with_engine(&engine.engine());
+    let mut store = Store::new(engine);
     let mut env = FunctionEnv::new(&mut store, ());
     let module = Module::new(&store, wasm_bytes)?;