feat(interface-types) Implement Interface Types (WIT)

Cargo.toml

@@ -64,6 +64,7 @@ members = [
     "lib/wasi-tests",
     "lib/emscripten-tests",
     "lib/middleware-common-tests",
+    "lib/interface-types",
     "examples/parallel",
     "examples/plugin-for-example",
     "examples/parallel-guest",

lib/interface-types/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "wasmer-interface-types"
+version = "0.13.1"
+description = "WebAssembly Interface Types library for Wasmer"
+license = "MIT"
+authors = ["The Wasmer Engineering Team <engineering@wasmer.io>"]
+repository = "https://github.com/wasmerio/wasmer"
+edition = "2018"
+
+[dependencies]
+nom = "5.1"

lib/interface-types/src/ast.rs

@@ -0,0 +1,209 @@
+//! Represents the WIT language as a tree. This is the central
+//! representation of the language.
+
+use crate::interpreter::Instruction;
+use std::str;
+
+/// Represents the types supported by WIT.
+#[derive(PartialEq, Clone, Debug)]
+pub enum InterfaceType {
+    /// An integer.
+    Int,
+
+    /// A float.
+    Float,
+
+    /// Opaque reference.
+    Any,
+
+    /// A string.
+    String,
+
+    /// A sequence.
+    Seq,
+
+    /// A 32-bits integer.
+    I32,
+
+    /// A 64-bits integer.
+    I64,
+
+    /// A 32-bits float.
+    F32,
+
+    /// A 64-bits float.
+    F64,
+
+    /// An `any` reference.
+    AnyRef,
+}
+
+/// Represents the kind of adapter.
+#[derive(PartialEq, Debug)]
+pub(crate) enum AdapterKind {
+    /// An adapter defined for an imported function of a WebAssembly instance.
+    Import,
+
+    /// An adapter defined for an exported function of a WebAssembly instance.
+    Export,
+
+    /// A helper function.
+    HelperFunction,
+}
+
+/// Represents an exported function signature.
+#[derive(PartialEq, Debug)]
+pub struct Export<'input> {
+    /// The function name.
+    pub name: &'input str,
+
+    /// The function input types.
+    pub input_types: Vec<InterfaceType>,
+
+    /// The function output types.
+    pub output_types: Vec<InterfaceType>,
+}
+
+/// Represents an imported function signature.
+#[derive(PartialEq, Debug)]
+pub struct Import<'input> {
+    /// The function namespace.
+    pub namespace: &'input str,
+
+    /// The function name.
+    pub name: &'input str,
+
+    /// The function input types.
+    pub input_types: Vec<InterfaceType>,
+
+    /// The function output types.
+    pub output_types: Vec<InterfaceType>,
+}
+
+/// Represents a structural type.
+#[derive(PartialEq, Debug)]
+pub struct Type<'input> {
+    /// The type name.
+    pub name: &'input str,
+
+    /// The field names.
+    field_names: Vec<&'input str>,
+
+    /// The field types.
+    field_types: Vec<InterfaceType>,
+}
+
+impl<'input> Type<'input> {
+    /// Creates a new `Type`.
+    ///
+    /// The constructor panics if there is the length of `names` is
+    /// different than the length of `types`.
+    pub fn new(type_name: &'input str, names: Vec<&'input str>, types: Vec<InterfaceType>) -> Self {
+        assert_eq!(
+            names.len(),
+            types.len(),
+            "There must be the same number of field names than field types."
+        );
+
+        Self {
+            name: type_name,
+            field_names: names,
+            field_types: types,
+        }
+    }
+
+    /// Adds a new field to the type.
+    pub fn add_field(&mut self, name: &'input str, ty: InterfaceType) {
+        self.field_names.push(name);
+        self.field_types.push(ty);
+    }
+
+    /// Returns the field names.
+    pub fn field_names(&self) -> &Vec<&'input str> {
+        &self.field_names
+    }
+
+    /// Returns the field types.
+    pub fn field_types(&self) -> &Vec<InterfaceType> {
+        &self.field_types
+    }
+}
+
+/// Represents an adapter.
+#[derive(PartialEq, Debug)]
+pub enum Adapter<'input> {
+    /// An adapter for an imported function.
+    Import {
+        /// The function namespace.
+        namespace: &'input str,
+
+        /// The function name.
+        name: &'input str,
+
+        /// The function input types.
+        input_types: Vec<InterfaceType>,
+
+        /// The function output types.
+        output_types: Vec<InterfaceType>,
+
+        /// The instructions of the adapter.
+        instructions: Vec<Instruction<'input>>,
+    },
+
+    /// An adapter for an exported function.
+    Export {
+        /// The function name.
+        name: &'input str,
+
+        /// The function input types.
+        input_types: Vec<InterfaceType>,
+
+        /// The function output types.
+        output_types: Vec<InterfaceType>,
+
+        /// The instructions of the adapter.
+        instructions: Vec<Instruction<'input>>,
+    },
+
+    /// An adapter for a helper function.
+    HelperFunction {
+        /// The helper name.
+        name: &'input str,
+
+        /// The helper input types.
+        input_types: Vec<InterfaceType>,
+
+        /// The helper output types.
+        output_types: Vec<InterfaceType>,
+
+        /// The instructions of the adapter.
+        instructions: Vec<Instruction<'input>>,
+    },
+}
+
+/// Represented a forwarded export.
+#[derive(PartialEq, Debug)]
+pub struct Forward<'input> {
+    /// The forwarded export name.
+    pub name: &'input str,
+}
+
+/// Represents a set of interfaces, i.e. it entirely describes a WIT
+/// definition.
+#[derive(PartialEq, Debug)]
+pub struct Interfaces<'input> {
+    /// All the exported functions.
+    pub exports: Vec<Export<'input>>,
+
+    /// All the types.
+    pub types: Vec<Type<'input>>,
+
+    /// All the imported functions.
+    pub imports: Vec<Import<'input>>,
+
+    /// All the adapters.
+    pub adapters: Vec<Adapter<'input>>,
+
+    /// All the forwarded functions.
+    pub forwards: Vec<Forward<'input>>,
+}