Struct aha_wit_parser::Interface

pub struct Interface {
    pub name: 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

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 validate_abi(&self, func: &Function) -> Result<(), String>

Validates the parameters/results of a function are representable in its ABI.

Returns an error string if they’re not representable or returns Ok if they’re indeed representable.

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 flags_repr(&self, record: &Record) -> Option<Int>

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 has_preview1_pointer(&self, ty: &Type) -> bool

Trait Implementations

impl Debug for Interface

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

Formats the value using the given formatter.