wasmtime 0.2.0 → 0.3.0

data/ext/src/ruby_api/func_type.rs

@@ -0,0 +1,139 @@
+use super::root;
+use crate::{define_rb_intern, err};
+use magnus::{function, method, Error, Module as _, Object, RArray, Symbol, Value};
+use wasmtime::{FuncType as FuncTypeImpl, ValType};
+
+define_rb_intern!(
+    I32 => "i32",
+    I64 => "i64",
+    F32 => "f32",
+    F64 => "f64",
+    V128 => "v128",
+    FUNCREF => "funcref",
+    EXTERNREF => "externref",
+);
+
+/// @yard
+/// Represents a Func's signature.
+/// @see https://docs.rs/wasmtime/latest/wasmtime/struct.FuncType.html Wasmtime's Rust doc
+#[derive(Clone, Debug)]
+#[magnus::wrap(class = "Wasmtime::FuncType")]
+pub struct FuncType {
+    inner: FuncTypeImpl,
+}
+
+impl FuncType {
+    pub fn get(&self) -> &FuncTypeImpl {
+        &self.inner
+    }
+}
+
+impl FuncType {
+    /// @yard
+    /// A descriptor for a function in a WebAssembly module.
+    /// WebAssembly functions can have 0 or more parameters and results. Each param
+    /// must be a valid WebAssembly type represented as a symbol. The valid symbols are:
+    /// +:i32+, +:i64+, +:f32+, +:f64+, +:v128+, +:funcref+, +:externref+.
+    ///
+    /// @def new(params, results)
+    /// @param params [Array<Symbol>] The function's parameter types.
+    /// @param results [Array<Symbol>] The function's result types.
+    /// @return [FuncType]
+    ///
+    /// @example +FuncType+ that takes 2 +i32+s and returns 1 +i32+:
+    ///   FuncType.new([:i32, :i32], [:i32])
+    pub fn new(params: RArray, results: RArray) -> Result<Self, Error> {
+        let inner = FuncTypeImpl::new(params.to_val_type_vec()?, results.to_val_type_vec()?);
+        Ok(Self { inner })
+    }
+
+    /// @yard
+    /// @return [Array<Symbol>] The function's parameter types.
+    pub fn params(&self) -> Vec<Symbol> {
+        self.get().params().map(ToSym::to_sym).collect()
+    }
+
+    /// @yard
+    /// @return [Array<Symbol>] The function's result types.
+    pub fn results(&self) -> Vec<Symbol> {
+        self.get().results().map(ToSym::to_sym).collect()
+    }
+}
+
+trait ToValType {
+    fn to_val_type(&self) -> Result<ValType, Error>;
+}
+
+impl ToValType for Value {
+    fn to_val_type(&self) -> Result<ValType, Error> {
+        if let Ok(symbol) = self.try_convert::<Symbol>() {
+            if let Ok(true) = symbol.equal(Symbol::from(*I32)) {
+                return Ok(ValType::I32);
+            }
+            if let Ok(true) = symbol.equal(Symbol::from(*I64)) {
+                return Ok(ValType::I64);
+            }
+            if let Ok(true) = symbol.equal(Symbol::from(*F32)) {
+                return Ok(ValType::F32);
+            }
+            if let Ok(true) = symbol.equal(Symbol::from(*F64)) {
+                return Ok(ValType::F64);
+            }
+            if let Ok(true) = symbol.equal(Symbol::from(*V128)) {
+                return Ok(ValType::V128);
+            }
+            if let Ok(true) = symbol.equal(Symbol::from(*FUNCREF)) {
+                return Ok(ValType::FuncRef);
+            }
+            if let Ok(true) = symbol.equal(Symbol::from(*EXTERNREF)) {
+                return Ok(ValType::ExternRef);
+            }
+        }
+
+        err!(
+            "invalid Webassembly type, expected one of [:i32, :i64, :f32, :f64, :v128, :funcref, :externref], got {:}",
+            self.inspect()
+        )
+    }
+}
+
+trait ToValTypeVec {
+    fn to_val_type_vec(&self) -> Result<Vec<ValType>, Error>;
+}
+
+impl ToValTypeVec for RArray {
+    fn to_val_type_vec(&self) -> Result<Vec<ValType>, Error> {
+        unsafe { self.as_slice() }
+            .iter()
+            .map(ToValType::to_val_type)
+            .collect::<Result<Vec<ValType>, Error>>()
+    }
+}
+
+trait ToSym {
+    fn to_sym(self) -> Symbol;
+}
+
+impl ToSym for ValType {
+    fn to_sym(self) -> Symbol {
+        match self {
+            ValType::I32 => Symbol::from(*I32),
+            ValType::I64 => Symbol::from(*I64),
+            ValType::F32 => Symbol::from(*F32),
+            ValType::F64 => Symbol::from(*F64),
+            ValType::V128 => Symbol::from(*V128),
+            ValType::FuncRef => Symbol::from(*FUNCREF),
+            ValType::ExternRef => Symbol::from(*EXTERNREF),
+        }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("FuncType", Default::default())?;
+
+    class.define_singleton_method("new", function!(FuncType::new, 2))?;
+    class.define_method("params", method!(FuncType::params, 0))?;
+    class.define_method("results", method!(FuncType::results, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/instance.rs

@@ -0,0 +1,174 @@
+use super::{
+    convert::{ToExtern, WrapWasmtimeType},
+    func::Func,
+    module::Module,
+    root,
+    store::{Store, StoreContextValue, StoreData},
+};
+use crate::{err, helpers::WrappedStruct};
+use magnus::{
+    function, method, scan_args, DataTypeFunctions, Error, Module as _, Object, RArray, RHash,
+    RString, TypedData, Value,
+};
+use wasmtime::{Extern, Instance as InstanceImpl, StoreContextMut};
+
+/// @yard
+/// Represents a WebAssembly instance.
+/// @see https://docs.rs/wasmtime/latest/wasmtime/struct.Instance.html Wasmtime's Rust doc
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Wasmtime::Instance", mark, free_immediatly)]
+pub struct Instance {
+    inner: InstanceImpl,
+    store: WrappedStruct<Store>,
+}
+
+unsafe impl Send for Instance {}
+
+impl DataTypeFunctions for Instance {
+    fn mark(&self) {
+        self.store.mark()
+    }
+}
+
+impl Instance {
+    /// @yard
+    /// @def new(store, mod, imports = [])
+    /// @param store [Store] The store to instantiate the module in.
+    /// @param mod [Module] The module to instantiate.
+    /// @param imports [Array<Func, Memory>]
+    ///   The module's import, in orders that that they show up in the module.
+    /// @return [Instance]
+    pub fn new(args: &[Value]) -> Result<Self, Error> {
+        let args =
+            scan_args::scan_args::<(Value, &Module), (Option<Value>,), (), (), (), ()>(args)?;
+        let (s, module) = args.required;
+        let wrapped_store: WrappedStruct<Store> = s.try_convert()?;
+        let store = wrapped_store.get()?;
+        let context = store.context_mut();
+        let imports = args
+            .optional
+            .0
+            .and_then(|v| if v.is_nil() { None } else { Some(v) });
+
+        let imports: Vec<Extern> = match imports {
+            Some(arr) => {
+                let arr: RArray = arr.try_convert()?;
+                let mut imports = Vec::with_capacity(arr.len());
+                for import in arr.each() {
+                    let import = import?;
+                    store.retain(import);
+                    imports.push(import.to_extern()?);
+                }
+                imports
+            }
+            None => vec![],
+        };
+
+        let module = module.get();
+        let inner = InstanceImpl::new(context, module, &imports)
+            .map_err(|e| StoreContextValue::from(wrapped_store).handle_wasm_error(e))?;
+
+        Ok(Self {
+            inner,
+            store: wrapped_store,
+        })
+    }
+
+    pub fn get(&self) -> InstanceImpl {
+        self.inner
+    }
+
+    pub fn from_inner(store: WrappedStruct<Store>, inner: InstanceImpl) -> Self {
+        Self { inner, store }
+    }
+
+    /// @yard
+    /// Returns a +Hash+ of exports where keys are export names as +String+s
+    /// and values are {Extern}s.
+    ///
+    /// @def exports
+    /// @return [Hash{String => Extern}]
+    pub fn exports(&self) -> Result<RHash, Error> {
+        let store = self.store.get()?;
+        let mut ctx = store.context_mut();
+        let hash = RHash::new();
+
+        for export in self.inner.exports(&mut ctx) {
+            let export_name: RString = export.name().into();
+            let wrapped_store = self.store;
+            let wrapped_export = export
+                .into_extern()
+                .wrap_wasmtime_type(wrapped_store.into())?;
+            hash.aset(export_name, wrapped_export)?;
+        }
+
+        Ok(hash)
+    }
+
+    /// @yard
+    /// Get an export by name.
+    ///
+    /// @def export(name)
+    /// @param name [String]
+    /// @return [Extern, nil] The export if it exists, nil otherwise.
+    pub fn export(&self, str: RString) -> Result<Option<super::externals::Extern>, Error> {
+        let store = self.store.get()?;
+        let export = self
+            .inner
+            .get_export(store.context_mut(), unsafe { str.as_str()? });
+        match export {
+            Some(export) => export.wrap_wasmtime_type(self.store.into()).map(Some),
+            None => Ok(None),
+        }
+    }
+
+    /// @yard
+    /// Retrieves a Wasm function from the instance and calls it.
+    /// Essentially a shortcut for +instance.export(name).call(...)+.
+    ///
+    /// @def invoke(name, *args)
+    /// @param name [String] The name of function  to run.
+    /// @param (see Func#call)
+    /// @return (see Func#call)
+    /// @see Func#call
+    pub fn invoke(&self, args: &[Value]) -> Result<Value, Error> {
+        let name: RString = args
+            .get(0)
+            .ok_or_else(|| {
+                Error::new(
+                    magnus::exception::type_error(),
+                    "wrong number of arguments (given 0, expected 1+)",
+                )
+            })?
+            .try_convert()?;
+
+        let store: &Store = self.store.try_convert()?;
+        let func = self.get_func(store.context_mut(), unsafe { name.as_str()? })?;
+        Func::invoke(&self.store.into(), &func, &args[1..]).map_err(|e| e.into())
+    }
+
+    fn get_func(
+        &self,
+        context: StoreContextMut<'_, StoreData>,
+        name: &str,
+    ) -> Result<wasmtime::Func, Error> {
+        let instance = self.inner;
+
+        if let Some(func) = instance.get_func(context, name) {
+            Ok(func)
+        } else {
+            err!("function \"{}\" not found", name)
+        }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Instance", Default::default())?;
+
+    class.define_singleton_method("new", function!(Instance::new, -1))?;
+    class.define_method("invoke", method!(Instance::invoke, -1))?;
+    class.define_method("exports", method!(Instance::exports, 0))?;
+    class.define_method("export", method!(Instance::export, 1))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/linker.rs

@@ -0,0 +1,296 @@
+use super::{
+    convert::WrapWasmtimeType,
+    engine::Engine,
+    externals::Extern,
+    func::{self, Func},
+    func_type::FuncType,
+    instance::Instance,
+    module::Module,
+    root,
+    store::{Store, StoreContextValue, StoreData},
+};
+use crate::{error, helpers::WrappedStruct, ruby_api::convert::ToExtern};
+use magnus::{
+    block::Proc, function, gc, method, scan_args::scan_args, DataTypeFunctions, Error, Module as _,
+    Object, RHash, RString, TypedData, Value,
+};
+use std::cell::RefCell;
+use wasmtime::Linker as LinkerImpl;
+
+/// @yard
+/// @see https://docs.rs/wasmtime/latest/wasmtime/struct.Linker.html Wasmtime's Rust doc
+#[derive(TypedData)]
+#[magnus(class = "Wasmtime::Linker", size, mark, free_immediatly)]
+pub struct Linker {
+    inner: RefCell<LinkerImpl<StoreData>>,
+    refs: RefCell<Vec<Value>>,
+}
+
+unsafe impl Send for Linker {}
+
+impl DataTypeFunctions for Linker {
+    fn mark(&self) {
+        self.refs.borrow().iter().for_each(gc::mark);
+    }
+}
+
+impl Linker {
+    /// @yard
+    /// @def new(engine)
+    /// @param engine [Engine]
+    /// @return [Linker]
+    pub fn new(engine: &Engine) -> Result<Self, Error> {
+        Ok(Self {
+            inner: RefCell::new(LinkerImpl::new(engine.get())),
+            refs: Default::default(),
+        })
+    }
+
+    /// @yard
+    /// Allow shadowing.
+    /// @def allow_shadowing=(val)
+    /// @param val [Boolean]
+    pub fn set_allow_shadowing(&self, val: bool) {
+        self.inner.borrow_mut().allow_shadowing(val);
+    }
+
+    /// @yard
+    /// Allow unknown exports.
+    /// @def allow_unknown_exports=(val)
+    /// @param val [Boolean]
+    pub fn set_allow_unknown_exports(&self, val: bool) {
+        self.inner.borrow_mut().allow_unknown_exports(val);
+    }
+
+    /// @yard
+    /// Define unknown (unresolved) imports as functions which trap.
+    /// @def define_unknown_imports_as_traps(mod)
+    /// @param mod [Module]
+    /// @return [void]
+    pub fn define_unknown_imports_as_traps(&self, module: &Module) -> Result<(), Error> {
+        self.inner
+            .borrow_mut()
+            .define_unknown_imports_as_traps(module.get())
+            .map_err(|e| error!("{}", e))
+    }
+
+    /// @yard
+    /// Define an item in this linker.
+    /// @def define(mod, name, item)
+    /// @param mod [String] Module name
+    /// @param name [String] Import name
+    /// @param item [Func, Memory] The item to define.
+    /// @return [void]
+    pub fn define(&self, module: RString, name: RString, item: Value) -> Result<(), Error> {
+        let item = item.to_extern()?;
+
+        self.inner
+            .borrow_mut()
+            .define(unsafe { module.as_str()? }, unsafe { name.as_str()? }, item)
+            .map(|_| ())
+            .map_err(|e| error!("{}", e))
+    }
+
+    /// @yard
+    /// Define a function in this linker.
+    ///
+    /// @def func_new(mod, name, type, &block)
+    ///
+    /// @param mod [String] Module name
+    /// @param name [String] Import name
+    /// @param type [FuncType]
+    /// @param block [Block] See {Func.new} for block argument details.
+    /// @return [void]
+    /// @see Func.new
+    pub fn func_new(&self, args: &[Value]) -> Result<(), Error> {
+        let args = scan_args::<(RString, RString, &FuncType), (), (), (), RHash, Proc>(args)?;
+        let (module, name, ty) = args.required;
+        let callable = args.block;
+        let func_closure = func::make_func_closure(ty.get(), callable);
+
+        self.refs.borrow_mut().push(callable.into());
+
+        self.inner
+            .borrow_mut()
+            .func_new(
+                unsafe { module.as_str() }?,
+                unsafe { name.as_str() }?,
+                ty.get().clone(),
+                func_closure,
+            )
+            .map_err(|e| error!("{}", e))
+            .map(|_| ())
+    }
+
+    /// @yard
+    /// Looks up a previously defined item in this linker.
+    ///
+    /// @def get(store, mod, name)
+    /// @param store [Store]
+    /// @param mod [String] Module name
+    /// @param name [String] Import name
+    /// @return [Extern, nil] The item if it exists, nil otherwise.
+    pub fn get(
+        &self,
+        s: WrappedStruct<Store>,
+        module: RString,
+        name: RString,
+    ) -> Result<Option<Extern>, Error> {
+        let store: &Store = s.try_convert()?;
+        let ext =
+            self.inner
+                .borrow()
+                .get(store.context_mut(), unsafe { module.as_str() }?, unsafe {
+                    name.as_str()?
+                });
+
+        match ext {
+            None => Ok(None),
+            Some(ext) => ext.wrap_wasmtime_type(s.into()).map(Some),
+        }
+    }
+
+    /// @yard
+    /// Defines an entire {Instance} in this linker.
+    ///
+    /// @def instance(store, mod, instance)
+    /// @param store [Store]
+    /// @param mod [String] Module name
+    /// @param instance [Instance]
+    /// @return [void]
+    pub fn instance(
+        &self,
+        store: &Store,
+        module: RString,
+        instance: &Instance,
+    ) -> Result<(), Error> {
+        self.inner
+            .borrow_mut()
+            .instance(
+                store.context_mut(),
+                unsafe { module.as_str() }?,
+                instance.get(),
+            )
+            .map_err(|e| error!("{}", e))
+            .map(|_| ())
+    }
+
+    /// @yard
+    /// Defines automatic instantiation of a {Module} in this linker.
+    ///
+    /// @def module(store, name, mod)
+    /// @param store [Store]
+    /// @param name [String] Module name
+    /// @param mod [Module]
+    /// @return [void]
+    pub fn module(&self, store: &Store, name: RString, module: &Module) -> Result<(), Error> {
+        self.inner
+            .borrow_mut()
+            .module(store.context_mut(), unsafe { name.as_str()? }, module.get())
+            .map(|_| ())
+            .map_err(|e| error!("{}", e))
+    }
+
+    /// @yard
+    /// Aliases one item’s name as another.
+    ///
+    /// @def alias(mod, name, as_mod, as_name)
+    /// @param mod [String] The source module name.
+    /// @param name [String] The source item name.
+    /// @param as_mod [String] The destination module name.
+    /// @param as_name [String] The destination item name.
+    /// @return [void]
+    pub fn alias(
+        &self,
+        module: RString,
+        name: RString,
+        as_module: RString,
+        as_name: RString,
+    ) -> Result<(), Error> {
+        self.inner
+            .borrow_mut()
+            .alias(
+                unsafe { module.as_str() }?,
+                unsafe { name.as_str() }?,
+                unsafe { as_module.as_str() }?,
+                unsafe { as_name.as_str() }?,
+            )
+            .map_err(|e| error!("{}", e))
+            .map(|_| ())
+    }
+
+    /// @yard
+    /// Aliases one module’s name as another.
+    ///
+    /// @def alias(mod, as_mod)
+    /// @param mod [String] Source module name
+    /// @param as_mod [String] Destination module name
+    /// @return [void]
+    pub fn alias_module(&self, module: RString, as_module: RString) -> Result<(), Error> {
+        self.inner
+            .borrow_mut()
+            .alias_module(unsafe { module.as_str() }?, unsafe { as_module.as_str() }?)
+            .map_err(|e| error!("{}", e))
+            .map(|_| ())
+    }
+
+    /// @yard
+    /// Instantiates a {Module} in a {Store} using the defined imports in the linker.
+    /// @def instantiate(store, mod)
+    /// @param store [Store]
+    /// @param mod [Module]
+    /// @return [Instance]
+    pub fn instantiate(&self, s: WrappedStruct<Store>, module: &Module) -> Result<Instance, Error> {
+        let wrapped_store: WrappedStruct<Store> = s.try_convert()?;
+        let store = wrapped_store.get()?;
+        self.inner
+            .borrow_mut()
+            .instantiate(store.context_mut(), module.get())
+            .map_err(|e| StoreContextValue::from(wrapped_store).handle_wasm_error(e))
+            .map(|instance| {
+                self.refs.borrow().iter().for_each(|val| store.retain(*val));
+                Instance::from_inner(s, instance)
+            })
+    }
+
+    /// @yard
+    /// Returns the “default export” of a module.
+    /// @def get_default(store, mod)
+    /// @param store [Store]
+    /// @param mod [String] Module name
+    /// @return [Func]
+    pub fn get_default(&self, s: WrappedStruct<Store>, module: RString) -> Result<Func, Error> {
+        let store = s.get()?;
+
+        self.inner
+            .borrow()
+            .get_default(store.context_mut(), unsafe { module.as_str() }?)
+            .map(|func| Func::from_inner(s.into(), func))
+            .map_err(|e| error!("{}", e))
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Linker", Default::default())?;
+    class.define_singleton_method("new", function!(Linker::new, 1))?;
+    class.define_method("allow_shadowing=", method!(Linker::set_allow_shadowing, 1))?;
+    class.define_method(
+        "allow_unknown_exports=",
+        method!(Linker::set_allow_unknown_exports, 1),
+    )?;
+    class.define_method(
+        "define_unknown_imports_as_traps",
+        method!(Linker::define_unknown_imports_as_traps, 1),
+    )?;
+    class.define_method("define", method!(Linker::define, 3))?;
+    class.define_method("func_new", method!(Linker::func_new, -1))?;
+    class.define_method("get", method!(Linker::get, 3))?;
+    class.define_method("instance", method!(Linker::instance, 3))?;
+    class.define_method("module", method!(Linker::module, 3))?;
+    class.define_method("alias", method!(Linker::alias, 4))?;
+    class.define_method("alias_module", method!(Linker::alias_module, 2))?;
+    class.define_method("instantiate", method!(Linker::instantiate, 2))?;
+    class.define_method("get_default", method!(Linker::get_default, 2))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/macros.rs

@@ -0,0 +1,12 @@
+/// A macro to define a new `Id` const for a given string.
+#[macro_export]
+macro_rules! define_rb_intern {
+    ($($name:ident => $id:expr,)*) => {
+        $(
+            lazy_static::lazy_static! {
+                /// Define a Ruby internal `Id`. Equivalent to `rb_intern("$name")`
+                pub static ref $name: $crate::ruby_api::static_id::StaticId = $crate::ruby_api::static_id::StaticId::intern_str($id);
+            }
+        )*
+    };
+}