Struct wasmer_wit_parser::Interface

pub struct Interface {
    pub name: String,
    pub module: Option<String>,
    pub types: Arena<TypeDef>,
    pub type_lookup: HashMap<String, TypeId>,
    pub resources: Arena<Resource>,
    pub resource_lookup: HashMap<String, ResourceId>,
    pub interfaces: Arena<Interface>,
    pub interface_lookup: HashMap<String, InterfaceId>,
    pub functions: Vec<Function>,
    pub globals: Vec<Global>,
}

Fields

name: String

module: Option<String>

The module name to use for bindings generation.

If None, then the interface name will be used.

If Some, then this value is used to format an export name of <module>#<name> for exports or an import module name of <module> for imports.

types: Arena<TypeDef>

type_lookup: HashMap<String, TypeId>

resources: Arena<Resource>

resource_lookup: HashMap<String, ResourceId>

interfaces: Arena<Interface>

interface_lookup: HashMap<String, InterfaceId>

functions: Vec<Function>

globals: Vec<Global>

Implementations

impl Interface

pub fn wasm_signature(
    &self,
    variant: AbiVariant,
    func: &Function
) -> WasmSignature

Get the WebAssembly type signature for this interface function

The first entry returned is the list of parameters and the second entry is the list of results for the wasm function signature.

pub fn call(
    &self,
    variant: AbiVariant,
    lift_lower: LiftLower,
    func: &Function,
    bindgen: &mut impl Bindgen
)

Generates an abstract sequence of instructions which represents this function being adapted as an imported function.

The instructions here, when executed, will emulate a language with interface types calling the concrete wasm implementation. The parameters for the returned instruction sequence are the language’s own interface-types parameters. One instruction in the instruction stream will be a Call which represents calling the actual raw wasm function signature.

This function is useful, for example, if you’re building a language generator for WASI bindings. This will document how to translate language-specific values into the wasm types to call a WASI function, and it will also automatically convert the results of the WASI function back to a language-specific value.

impl Interface

pub fn parse(name: &str, input: &str) -> Result<Interface>

pub fn parse_file(path: impl AsRef<Path>) -> Result<Interface>

pub fn parse_with(
    filename: impl AsRef<Path>,
    contents: &str,
    load: impl FnMut(&str) -> Result<(PathBuf, String)>
) -> Result<Interface>

pub fn topological_types(&self) -> Vec<TypeId>

pub fn all_bits_valid(&self, ty: &Type) -> bool

pub fn get_variant(&self, ty: &Type) -> Option<&Variant>

Trait Implementations

impl Clone for Interface

fn clone(&self) -> Interface

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Interface

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Interface

fn default() -> Interface

Returns the “default value” for a type.

impl PartialEq<Interface> for Interface

fn eq(&self, other: &Interface) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Interface