feat: Update to Wasmer 2.0.

The only breaking change is the renaming of the engines: JIT becomes
Universal, and Native becomes Dylib. To avoid this breaking change,
JIT extends Universal and Native extends Dylib, and they become
deprecated.

Test cases have been added to ensure the same behavior with JIT and
Native.

Author: Hywan

Cargo.lock

@@ -32,8 +32,8 @@ <h1 class="title">Module <code>engine</code></h1>
 </ol>
 <p>It currently has two implementations:</p>
 <ol>
-<li>JIT with <code><a title="engine.JIT" href="#engine.JIT">JIT</a></code>,</li>
-<li>Native with <code><a title="engine.Native" href="#engine.Native">Native</a></code>.</li>
+<li>Universal with <code><a title="engine.Universal" href="#engine.Universal">Universal</a></code>,</li>
+<li>Dylib with <code><a title="engine.Dylib" href="#engine.Dylib">Dylib</a></code>.</li>
 </ol>
 <p>Both engines receive an optional compiler. If absent, engines will
 run in headless mode, i.e. they won't be able to compile (create)
@@ -42,20 +42,20 @@ <h1 class="title">Module <code>engine</code></h1>
 <ul>
 <li><code><a title="wasmer_compiler_cranelift" href="../wasmer_compiler_cranelift/index.html">wasmer_compiler_cranelift</a></code> to use the Cranelift compiler,</li>
 <li><code><a title="wasmer_compiler_llvm" href="../wasmer_compiler_llvm/index.html">wasmer_compiler_llvm</a></code> to use the LLVM compiler,</li>
-<li><code><a title="wasmer_compiler_singlepass" href="../wasmer_compiler_singlepass/index.html">wasmer_compiler_singlepass</a></code> to use the Singlepass compiler.</li>
+<li><code>wasmer_compiler_singlepass</code> to use the Singlepass compiler.</li>
 </ul>
 <h2 id="example">Example</h2>
-<p>Create a JIT engine with no compiler (headless mode):</p>
+<p>Create a Universal engine with no compiler (headless mode):</p>
 <pre><code class="language-py">from wasmer import engine
 
-engine = engine.JIT()
-</code></pre>
-<p>Create a JIT engine with the LLVM compiler:</p>
-<pre><code class="language-py">from wasmer import engine
-from wasmer_compiler_llvm import Compiler
-
-engine = engine.JIT(Compiler)
+engine = engine.Universal()
 </code></pre>
+<p>Create a Universal engine with the LLVM compiler:</p>
+<p>```py,ignore
+from wasmer import engine
+from wasmer_compiler_llvm import Compiler</p>
+<p>engine = engine.Universal(Compiler)
+```</p>
 <p>Engines are stored inside the <code><a title="wasmer.Store" href="../wasmer/index.html#wasmer.Store">Store</a></code>.</p>
 </section>
 <section>
@@ -67,31 +67,63 @@ <h2 id="example">Example</h2>
 <section>
 <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
-<dt id="engine.JIT"><code class="flex name class">
-<span>class <span class="ident">JIT</span></span>
+<dt id="engine.Dylib"><code class="flex name class">
+<span>class <span class="ident">Dylib</span></span>
 <span>(</span><span>compiler, target, /)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>JIT engine for Wasmer compilers.</p>
-<p>Given an optional compiler, it generates the compiled machine code,
+<div class="desc"><p>Dylib engine for Wasmer compilers.</p>
+<p>Given an optional compiler, it generates a shared object file
+(<code>.so</code>, <code>.dylib</code> or <code>.dll</code> depending on the target), saves it
+temporarily to disk and uses it dylibly via <code>dlopen</code> and <code>dlsym</code>.
 and publishes it into memory so it can be used externally.</p>
 <p>If the compiler is absent, it will generate a headless engine.</p>
 <p>It is possible to specify a <code>Target</code> to possibly cross-compile for
 a different target. It requires a compiler.</p></div>
+<h3>Subclasses</h3>
+<ul class="hlist">
+<li>builtins.Native</li>
+</ul>
+</dd>
+<dt id="engine.JIT"><code class="flex name class">
+<span>class <span class="ident">JIT</span></span>
+<span>(</span><span>compiler, target, /)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Deprecated engine. Please use the parent engine instead,
+i.e. <code><a title="engine.Universal" href="#engine.Universal">Universal</a></code>.</p></div>
+<h3>Ancestors</h3>
+<ul class="hlist">
+<li>builtins.Universal</li>
+</ul>
 </dd>
 <dt id="engine.Native"><code class="flex name class">
 <span>class <span class="ident">Native</span></span>
 <span>(</span><span>compiler, target, /)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Native engine for Wasmer compilers.</p>
-<p>Given an optional compiler, it generates a shared object file
-(<code>.so</code>, <code>.dylib</code> or <code>.dll</code> depending on the target), saves it
-temporarily to disk and uses it natively via <code>dlopen</code> and <code>dlsym</code>.
+<div class="desc"><p>Deprecated engine. Please use the parent engine instead,
+i.e. <code><a title="engine.Dylib" href="#engine.Dylib">Dylib</a></code>.</p></div>
+<h3>Ancestors</h3>
+<ul class="hlist">
+<li>builtins.Dylib</li>
+</ul>
+</dd>
+<dt id="engine.Universal"><code class="flex name class">
+<span>class <span class="ident">Universal</span></span>
+<span>(</span><span>compiler, target, /)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Universal engine for Wasmer compilers.</p>
+<p>Given an optional compiler, it generates the compiled machine code,
 and publishes it into memory so it can be used externally.</p>
 <p>If the compiler is absent, it will generate a headless engine.</p>
 <p>It is possible to specify a <code>Target</code> to possibly cross-compile for
 a different target. It requires a compiler.</p></div>
+<h3>Subclasses</h3>
+<ul class="hlist">
+<li>builtins.JIT</li>
+</ul>
 </dd>
 </dl>
 </section>
@@ -112,11 +144,17 @@ <h1>Index</h1>
 <li><h3><a href="#header-classes">Classes</a></h3>
 <ul>
 <li>
+<h4><code><a title="engine.Dylib" href="#engine.Dylib">Dylib</a></code></h4>
+</li>
+<li>
 <h4><code><a title="engine.JIT" href="#engine.JIT">JIT</a></code></h4>
 </li>
 <li>
 <h4><code><a title="engine.Native" href="#engine.Native">Native</a></code></h4>
 </li>
+<li>
+<h4><code><a title="engine.Universal" href="#engine.Universal">Universal</a></code></h4>
+</li>
 </ul>
 </li>
 </ul>

docs/api/engine/index.html

@@ -32,43 +32,37 @@ <h1 class="title">Module <code>target</code></h1>
 target for the compiler. A <code><a title="target.Target" href="#target.Target">Target</a></code> is defined by a <code><a title="target.Triple" href="#target.Triple">Triple</a></code> and
 <code><a title="target.CpuFeatures" href="#target.CpuFeatures">CpuFeatures</a></code> (optional).</p>
 <h2 id="example">Example</h2>
-<pre><code class="language-py">from wasmer import engine, target, Store, Module
-from wasmer_compiler_cranelift import Compiler
-
-# Build a triple from a string.
-triple = target.Triple('x86_64-linux-musl')
-
-# Build the CPU features (optional).
-cpu_features = target.CpuFeatures()
-cpu_features.add('sse2')
-
-# Build the target.
-target = target.Target(triple, cpu_features)
-
-# There we go. When creating the engine, pass the compiler _and_
-# the target.
-engine = engine.Native(Compiler, target)
-
-# And finally, build the store with the engine.
-store = Store(engine)
-
-# Now, let's compile the module for the defined target.
-module = Module(
-    store,
-    &quot;&quot;&quot;
-    (module
-    (type $sum_t (func (param i32 i32) (result i32)))
-    (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
-        local.get $x
-        local.get $y
-        i32.add)
-    (export &quot;sum&quot; (func $sum_f)))
-    &quot;&quot;&quot;
-)
-
-# What's next? Serialize the module, and execute it on the
-# targeted host.
-</code></pre>
+<p>```py,ignore
+from wasmer import engine, target, Store, Module
+from wasmer_compiler_cranelift import Compiler</p>
+<h1 id="build-a-triple-from-a-string">Build a triple from a string.</h1>
+<p>triple = target.Triple('x86_64-linux-musl')</p>
+<h1 id="build-the-cpu-features-optional">Build the CPU features (optional).</h1>
+<p>cpu_features = target.CpuFeatures()
+cpu_features.add('sse2')</p>
+<h1 id="build-the-target">Build the target.</h1>
+<p>target = target.Target(triple, cpu_features)</p>
+<h1 id="there-we-go-when-creating-the-engine-pass-the-compiler-and">There we go. When creating the engine, pass the compiler <em>and</em></h1>
+<h1 id="the-target">the target.</h1>
+<p>engine = engine.Dylib(Compiler, target)</p>
+<h1 id="and-finally-build-the-store-with-the-engine">And finally, build the store with the engine.</h1>
+<p>store = Store(engine)</p>
+<h1 id="now-lets-compile-the-module-for-the-defined-target">Now, let's compile the module for the defined target.</h1>
+<p>module = Module(
+store,
+"""
+(module
+(type $sum_t (func (param i32 i32) (result i32)))
+(func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+local.get $x
+local.get $y
+i32.add)
+(export "sum" (func $sum_f)))
+"""
+)</p>
+<h1 id="whats-next-serialize-the-module-and-execute-it-on-the">What's next? Serialize the module, and execute it on the</h1>
+<h1 id="targeted-host">targeted host.</h1>
+<p>```</p>
 </section>
 <section>
 </section>
@@ -251,6 +245,15 @@ <h1>Index</h1>
 <div class="toc">
 <ul>
 <li><a href="#example">Example</a></li>
+<li><a href="#build-a-triple-from-a-string">Build a triple from a string.</a></li>
+<li><a href="#build-the-cpu-features-optional">Build the CPU features (optional).</a></li>
+<li><a href="#build-the-target">Build the target.</a></li>
+<li><a href="#there-we-go-when-creating-the-engine-pass-the-compiler-and">There we go. When creating the engine, pass the compiler and</a></li>
+<li><a href="#the-target">the target.</a></li>
+<li><a href="#and-finally-build-the-store-with-the-engine">And finally, build the store with the engine.</a></li>
+<li><a href="#now-lets-compile-the-module-for-the-defined-target">Now, let's compile the module for the defined target.</a></li>
+<li><a href="#whats-next-serialize-the-module-and-execute-it-on-the">What's next? Serialize the module, and execute it on the</a></li>
+<li><a href="#targeted-host">targeted host.</a></li>
 </ul>
 </div>
 <ul id="index">

docs/api/target/index.html

@@ -49,10 +49,6 @@ <h2 id="example">Example</h2>
 # Now we are ready to instantiate the module.
 instance = Instance(module, import_object)
 
-# … But (!) WASI needs an access to the memory of the
-# module. Simple, pass it.
-wasi_env.memory = instance.exports.memory
-
 # Here we go, let's start the program.
 instance.exports._start()
 </code></pre>
@@ -82,44 +78,12 @@ <h2 class="section-title" id="header-classes">Classes</h2>
 <dl>
 <dt id="wasi.Environment"><code class="flex name class">
 <span>class <span class="ident">Environment</span></span>
+<span>(</span><span>...)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>The environment provided to the WASI imports.</p>
 <p>To build it, use <code><a title="wasi.StateBuilder" href="#wasi.StateBuilder">StateBuilder</a></code>. See <code><a title="wasi.StateBuilder.finalize" href="#wasi.StateBuilder.finalize">StateBuilder.finalize()</a></code> to
 learn more.</p></div>
-<h3>Instance variables</h3>
-<dl>
-<dt id="wasi.Environment.memory"><code class="name">var <span class="ident">memory</span></code></dt>
-<dd>
-<div class="desc"><p>Set a memory to the WASI. Usually, it is a <code><a title="wasmer.Memory" href="../wasmer/index.html#wasmer.Memory">Memory</a></code>
-object from <code>instance.exports.&lt;memory_name&gt;</code>.</p>
-<h2 id="example">Example</h2>
-<pre><code class="language-py">from wasmer import wasi, Store, Module, Instance
-
-store = Store()
-module = Module(store, open('tests/wasi.wasm', 'rb').read())
-
-# Get the WASI version.
-wasi_version = wasi.get_version(module, strict=True)
-
-# Build a WASI environment for the imports.
-wasi_env = wasi.StateBuilder('test-program').argument('--foo').finalize()
-
-# Generate an `ImportObject` from the WASI environment.
-import_object = wasi_env.generate_import_object(store, wasi_version)
-
-# Now we are ready to instantiate the module.
-instance = Instance(module, import_object)
-
-# … But (!) WASI needs an access to the memory of the
-# module. Simple, pass it.
-wasi_env.memory = instance.exports.memory
-
-# Here we go, let's start the program.
-instance.exports._start()
-</code></pre></div>
-</dd>
-</dl>
 <h3>Methods</h3>
 <dl>
 <dt id="wasi.Environment.generate_import_object"><code class="name flex">
@@ -135,7 +99,7 @@ <h2 id="example">Example</h2>
 <pre><code class="language-py">from wasmer import wasi, Store
 
 store = Store()
-wasi_env = wasi.StateBuilder('test-program').argument('--foo')
+wasi_env = wasi.StateBuilder('test-program').argument('--foo').finalize()
 import_object = wasi_env.generate_import_object(store, wasi.Version.SNAPSHOT1)
 </code></pre></div>
 </dd>
@@ -277,7 +241,7 @@ <h2 id="example">Example</h2>
 
 wasi_state_builder = \
     wasi.StateBuilder('test-program'). \
-        preopen_directories([&quot;foo&quot;, &quot;bar&quot;])
+        preopen_directories([&quot;.&quot;])
 </code></pre></div>
 </dd>
 <dt id="wasi.StateBuilder.preopen_directory"><code class="name flex">
@@ -290,13 +254,12 @@ <h2 id="example">Example</h2>
 directory.</p>
 <p>This method returns <code>self</code>.</p>
 <h2 id="example">Example</h2>
-<pre><code class="language-py">from wasmer import wasi
-
-wasi_state_builder = \
-    wasi.StateBuilder('test-program'). \
-        preopen_directory(&quot;foo&quot;). \
-        preopen_directory(&quot;bar&quot;)
-</code></pre></div>
+<p>```py,ignore
+from wasmer import wasi</p>
+<p>wasi_state_builder = \
+wasi.StateBuilder('test-program'). \
+preopen_directory(".")
+```</p></div>
 </dd>
 </dl>
 </dd>
@@ -355,7 +318,6 @@ <h1>Index</h1>
 <h4><code><a title="wasi.Environment" href="#wasi.Environment">Environment</a></code></h4>
 <ul class="">
 <li><code><a title="wasi.Environment.generate_import_object" href="#wasi.Environment.generate_import_object">generate_import_object</a></code></li>
-<li><code><a title="wasi.Environment.memory" href="#wasi.Environment.memory">memory</a></code></li>
 </ul>
 </li>
 <li>