feat: simplify module api

Signed-off-by: Henry <mail@henrygressmann.de>

9 files changed, 43 insertions, 43 deletions

diff --git a/examples/archive.rs b/examples/archive.rs
index f8d309c..7a2ebab 100644
--- a/examples/archive.rs
+++ b/examples/archive.rs
@@ -1,5 +1,5 @@
 use eyre::Result;
-use tinywasm::{Module, Store, parser::Parser, types::TinyWasmModule};
+use tinywasm::{Module, ModuleInstance, Store, parser::Parser};
 
 const WASM: &str = r#"
 (module
@@ -18,9 +18,9 @@ fn main() -> Result<()> {
     // Now, you could e.g. write `twasm` to a file called `add.twasm`
     // and load it later in a different program.
 
-    let module: Module = TinyWasmModule::from_twasm(&twasm)?.into();
+    let module = Module::try_from_twasm(&twasm)?;
     let mut store = Store::default();
-    let instance = module.instantiate(&mut store, None)?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, None)?;
     let add = instance.func::<(i32, i32), i32>(&store, "add")?;
 
     assert_eq!(add.call(&mut store, (1, 2))?, 3);
diff --git a/examples/funcref_callbacks.rs b/examples/funcref_callbacks.rs
index f517e30..8ff9b49 100644
--- a/examples/funcref_callbacks.rs
+++ b/examples/funcref_callbacks.rs
@@ -1,5 +1,5 @@
 use eyre::Result;
-use tinywasm::{FuncContext, HostFunction, Imports, Module, Store, types::FuncRef};
+use tinywasm::{FuncContext, HostFunction, Imports, ModuleInstance, Store, types::FuncRef};
 
 const LHS: i32 = 5;
 const RHS: i32 = 3;
@@ -47,7 +47,7 @@ fn run_passed_funcref_example() -> Result<()> {
     "#;
 
     let wasm = wat::parse_str(WASM).expect("failed to parse wat");
-    let module = Module::parse_bytes(&wasm)?;
+    let module = tinywasm::parse_bytes(&wasm)?;
     let mut store = Store::default();
 
     let mul = HostFunction::from(&mut store, |_, (lhs, rhs): (i32, i32)| -> tinywasm::Result<i32> { Ok(lhs * rhs) });
@@ -62,7 +62,7 @@ fn run_passed_funcref_example() -> Result<()> {
     let mut imports = Imports::new();
     imports.define("host", "call_this", call_this).define("host", "mul", mul);
 
-    let instance = module.instantiate(&mut store, Some(imports))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))?;
     let caller = instance.func::<(), ()>(&store, "tell_host_to_call")?;
 
     caller.call(&mut store, ())?;
@@ -103,14 +103,14 @@ fn run_returned_funcref_example() -> Result<()> {
     "#;
 
     let wasm = wat::parse_str(WASM).expect("failed to parse wat");
-    let module = Module::parse_bytes(&wasm)?;
+    let module = tinywasm::parse_bytes(&wasm)?;
     let mut store = Store::default();
     let mut imports = Imports::new();
 
     let mul = HostFunction::from(&mut store, |_, (lhs, rhs): (i32, i32)| -> tinywasm::Result<i32> { Ok(lhs * rhs) });
     imports.define("host", "mul", mul);
 
-    let instance = module.instantiate(&mut store, Some(imports))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))?;
     let (add_ref, sub_ref, mul_ref) = {
         let get_funcrefs = instance.func::<(), (FuncRef, FuncRef, FuncRef)>(&store, "what_should_host_call")?;
         get_funcrefs.call(&mut store, ())?
diff --git a/examples/linking.rs b/examples/linking.rs
index 4da7fec..b3164ae 100644
--- a/examples/linking.rs
+++ b/examples/linking.rs
@@ -1,5 +1,5 @@
 use eyre::Result;
-use tinywasm::{Module, Store};
+use tinywasm::{ModuleInstance, Store};
 
 // WebAssembly module defining and exporting an `add` function.
 const WASM_ADD: &str = r#"
@@ -27,20 +27,20 @@ fn main() -> Result<()> {
     let wasm_add = wat::parse_str(WASM_ADD).expect("failed to parse wat");
     let wasm_import = wat::parse_str(WASM_IMPORT).expect("failed to parse wat");
 
-    let add_module = Module::parse_bytes(&wasm_add)?;
-    let import_module = Module::parse_bytes(&wasm_import)?;
+    let add_module = tinywasm::parse_bytes(&wasm_add)?;
+    let import_module = tinywasm::parse_bytes(&wasm_import)?;
 
     let mut store = Store::default();
 
     // Instantiate the `add` module.
-    let add_instance = add_module.instantiate(&mut store, None)?;
+    let add_instance = ModuleInstance::instantiate(&mut store, &add_module, None)?;
 
     // Link the `adder` namespace to the `add` module's instance.
     let mut imports = tinywasm::Imports::new();
     imports.link_module("adder", add_instance)?;
 
     // Instantiate the `import` module with the linked imports.
-    let import_instance = import_module.instantiate(&mut store, Some(imports))?;
+    let import_instance = ModuleInstance::instantiate(&mut store, &import_module, Some(imports))?;
 
     // Call the `main` function, which uses the imported `add` function.
     let main = import_instance.func::<(), i32>(&store, "main")?;
diff --git a/examples/resumable.rs b/examples/resumable.rs
index fef01dd..0163414 100644
--- a/examples/resumable.rs
+++ b/examples/resumable.rs
@@ -1,5 +1,5 @@
 use eyre::Result;
-use tinywasm::{ExecProgress, Module, Store};
+use tinywasm::{ExecProgress, ModuleInstance, Store};
 
 const WASM: &str = r#"
 (module
@@ -24,9 +24,9 @@ const WASM: &str = r#"
 
 fn main() -> Result<()> {
     let wasm = wat::parse_str(WASM)?;
-    let module = Module::parse_bytes(&wasm)?;
+    let module = tinywasm::parse_bytes(&wasm)?;
     let mut store = Store::default();
-    let instance = module.instantiate(&mut store, None)?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, None)?;
     let count_down = instance.func::<i32, i32>(&store, "count_down")?;
 
     let mut execution = count_down.call_resumable(&mut store, 10_000)?;
diff --git a/examples/rust/src/tinywasm.rs b/examples/rust/src/tinywasm.rs
index 0ccb026..70de73e 100644
--- a/examples/rust/src/tinywasm.rs
+++ b/examples/rust/src/tinywasm.rs
@@ -1,5 +1,5 @@
 #![no_main]
-use tinywasm::{FuncContext, HostFunction};
+use tinywasm::{FuncContext, HostFunction, ModuleInstance};
 
 #[link(wasm_import_module = "env")]
 unsafe extern "C" {
@@ -12,7 +12,7 @@ pub extern "C" fn hello() {
 }
 
 fn run() -> tinywasm::Result<()> {
-    let module = tinywasm::Module::parse_stream(&include_bytes!("./print.wasm")[..])?;
+    let module = tinywasm::parse_stream(&include_bytes!("./print.wasm")[..])?;
     let mut store = tinywasm::Store::default();
 
     let printi32 = HostFunction::from(&mut store, |_: FuncContext<'_>, v: i32| {
@@ -23,7 +23,7 @@ fn run() -> tinywasm::Result<()> {
     let mut imports = tinywasm::Imports::new();
     imports.define("env", "printi32", printi32);
 
-    let instance = module.instantiate(&mut store, Some(imports))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))?;
     let add_and_print = instance.func::<(i32, i32), ()>(&store, "add_and_print")?;
     add_and_print.call(&mut store, (1, 2))?;
     Ok(())
diff --git a/examples/rust/src/tinywasm_no_std.rs b/examples/rust/src/tinywasm_no_std.rs
index 6d7e73c..c1dd910 100644
--- a/examples/rust/src/tinywasm_no_std.rs
+++ b/examples/rust/src/tinywasm_no_std.rs
@@ -1,7 +1,7 @@
 #![no_main]
 #![no_std]
 use dlmalloc::GlobalDlmalloc;
-use tinywasm::{FuncContext, HostFunction};
+use tinywasm::{FuncContext, HostFunction, ModuleInstance};
 
 extern crate alloc;
 
@@ -30,7 +30,7 @@ fn run() -> tinywasm::Result<()> {
 
     let res = tinywasm::parser::Parser::new().parse_module_bytes(include_bytes!("./print.wasm"))?;
     let twasm = res.serialize_twasm()?;
-    let module = tinywasm::Module::parse_bytes(&twasm)?;
+    let module = tinywasm::parse_bytes(&twasm)?;
 
     let printi32 = HostFunction::from(&mut store, |_: FuncContext<'_>, v: i32| {
         unsafe { printi32(v) }
@@ -38,7 +38,7 @@ fn run() -> tinywasm::Result<()> {
     });
 
     imports.define("env", "printi32", printi32);
-    let instance = module.instantiate(&mut store, Some(imports))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))?;
     let add_and_print = instance.func::<(i32, i32), ()>(&store, "add_and_print")?;
     add_and_print.call(&mut store, (1, 2))?;
     Ok(())
diff --git a/examples/simple.rs b/examples/simple.rs
index 38839c9..a902b4c 100644
--- a/examples/simple.rs
+++ b/examples/simple.rs
@@ -1,5 +1,5 @@
 use eyre::Result;
-use tinywasm::{Module, Store};
+use tinywasm::{ModuleInstance, Store};
 
 const WASM: &str = r#"
 (module
@@ -12,9 +12,9 @@ const WASM: &str = r#"
 
 fn main() -> Result<()> {
     let wasm = wat::parse_str(WASM).expect("failed to parse wat");
-    let module = Module::parse_bytes(&wasm)?;
+    let module = tinywasm::parse_bytes(&wasm)?;
     let mut store = Store::default();
-    let instance = module.instantiate(&mut store, None)?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, None)?;
     let add = instance.func::<(i32, i32), i32>(&store, "add")?;
 
     assert_eq!(add.call(&mut store, (1, 2))?, 3);
diff --git a/examples/simple2.rs b/examples/simple2.rs
index f0d566e..da7def7 100644
--- a/examples/simple2.rs
+++ b/examples/simple2.rs
@@ -1,5 +1,5 @@
 use eyre::Result;
-use tinywasm::{Module, Store};
+use tinywasm::{ModuleInstance, Store};
 
 const WASM: &str = r#"
 (module
@@ -11,9 +11,9 @@ const WASM: &str = r#"
 
 fn main() -> Result<()> {
     let wasm = wat::parse_str(WASM).expect("failed to parse wat");
-    let module = Module::parse_bytes(&wasm)?;
+    let module = tinywasm::parse_bytes(&wasm)?;
     let mut store = Store::default();
-    let instance = module.instantiate(&mut store, None)?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, None)?;
     let add = instance.func::<(i32, i64), (i32, i64)>(&store, "return")?;
 
     assert_eq!(add.call(&mut store, (1, 2))?, (1, 2));
diff --git a/examples/wasm-rust.rs b/examples/wasm-rust.rs
index 928b9e1..7240bef 100644
--- a/examples/wasm-rust.rs
+++ b/examples/wasm-rust.rs
@@ -1,7 +1,7 @@
 use std::hint::black_box;
 
 use eyre::{Result, eyre};
-use tinywasm::{FuncContext, HostFunction, Imports, Module, Store};
+use tinywasm::{FuncContext, HostFunction, Imports, ModuleInstance, Store};
 
 /// Examples of using WebAssembly compiled from Rust with tinywasm.
 ///
@@ -72,12 +72,12 @@ fn main() -> Result<()> {
 }
 
 fn tinywasm() -> Result<()> {
-    let module = Module::parse_file("./examples/rust/out/tinywasm.opt.wasm")?;
+    let module = tinywasm::parse_file("./examples/rust/out/tinywasm.opt.wasm")?;
     let mut store = Store::default();
 
     let mut imports = Imports::new();
     imports.define("env", "printi32", HostFunction::from(&mut store, |_: FuncContext<'_>, _x: i32| Ok(())));
-    let instance = module.instantiate(&mut store, Some(black_box(imports)))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(black_box(imports)))?;
 
     let hello = instance.func::<(), ()>(&store, "hello")?;
     hello.call(&mut store, black_box(()))?;
@@ -87,12 +87,12 @@ fn tinywasm() -> Result<()> {
 }
 
 fn tinywasm_no_std() -> Result<()> {
-    let module = Module::parse_file("./examples/rust/out/tinywasm_no_std.wasm")?;
+    let module = tinywasm::parse_file("./examples/rust/out/tinywasm_no_std.wasm")?;
     let mut store = Store::default();
 
     let mut imports = Imports::new();
     imports.define("env", "printi32", HostFunction::from(&mut store, |_: FuncContext<'_>, _x: i32| Ok(())));
-    let instance = module.instantiate(&mut store, Some(black_box(imports)))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(black_box(imports)))?;
 
     let hello = instance.func::<(), ()>(&store, "hello")?;
     hello.call(&mut store, black_box(()))?;
@@ -102,7 +102,7 @@ fn tinywasm_no_std() -> Result<()> {
 }
 
 fn hello() -> Result<()> {
-    let module = Module::parse_file("./examples/rust/out/hello.opt.wasm")?;
+    let module = tinywasm::parse_file("./examples/rust/out/hello.opt.wasm")?;
     let mut store = Store::default();
 
     let print_utf8 = HostFunction::from(&mut store, |ctx: FuncContext<'_>, (ptr, len): (i64, i32)| {
@@ -115,7 +115,7 @@ fn hello() -> Result<()> {
     let mut imports = Imports::new();
     imports.define("env", "print_utf8", print_utf8);
 
-    let instance = module.instantiate(&mut store, Some(imports))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))?;
     let arg_ptr = instance.func::<(), i32>(&store, "arg_ptr")?.call(&mut store, ())?;
     let arg = b"world";
 
@@ -127,7 +127,7 @@ fn hello() -> Result<()> {
 }
 
 fn host_fn() -> Result<()> {
-    let module = Module::parse_file("./examples/rust/out/host_fn.opt.wasm")?;
+    let module = tinywasm::parse_file("./examples/rust/out/host_fn.opt.wasm")?;
     let mut store = Store::default();
 
     let bar = HostFunction::from(&mut store, |_: FuncContext<'_>, (left, right): (i64, i32)| {
@@ -139,14 +139,14 @@ fn host_fn() -> Result<()> {
     let mut imports = Imports::new();
     imports.define("env", "bar", bar);
 
-    let instance = module.instantiate(&mut store, Some(imports))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))?;
     let host_fn = instance.func::<(), i32>(&store, "foo")?;
     assert_eq!(host_fn.call(&mut store, ())?, 3);
     Ok(())
 }
 
 fn printi32() -> Result<()> {
-    let module = Module::parse_file("./examples/rust/out/print.opt.wasm")?;
+    let module = tinywasm::parse_file("./examples/rust/out/print.opt.wasm")?;
     let mut store = Store::default();
 
     let printi32 = HostFunction::from(&mut store, |_: FuncContext<'_>, x: i32| {
@@ -157,7 +157,7 @@ fn printi32() -> Result<()> {
     let mut imports = Imports::new();
     imports.define("env", "printi32", printi32);
 
-    let instance = module.instantiate(&mut store, Some(imports))?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))?;
     let add_and_print = instance.func::<(i32, i32), ()>(&store, "add_and_print")?;
     add_and_print.call(&mut store, (1, 2))?;
 
@@ -165,10 +165,10 @@ fn printi32() -> Result<()> {
 }
 
 fn fibonacci() -> Result<()> {
-    let module = Module::parse_file("./examples/rust/out/fibonacci.opt.wasm")?;
+    let module = tinywasm::parse_file("./examples/rust/out/fibonacci.opt.wasm")?;
     let mut store = Store::default();
 
-    let instance = module.instantiate(&mut store, None)?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, None)?;
     let fibonacci = instance.func::<i32, i32>(&store, "fibonacci_recursive")?;
     let n = 26;
     let result = fibonacci.call(&mut store, n)?;
@@ -178,10 +178,10 @@ fn fibonacci() -> Result<()> {
 }
 
 fn argon2id() -> Result<()> {
-    let module = Module::parse_file("./examples/rust/out/argon2id.opt.wasm")?;
+    let module = tinywasm::parse_file("./examples/rust/out/argon2id.opt.wasm")?;
     let mut store = Store::default();
 
-    let instance = module.instantiate(&mut store, None)?;
+    let instance = ModuleInstance::instantiate(&mut store, &module, None)?;
     let argon2id = instance.func::<(i32, i32, i32), i32>(&store, "argon2id")?;
     argon2id.call(&mut store, (1000, 2, 1))?;