Struct FunctionBindgen 

#[non_exhaustive]
pub struct FunctionBindgen<'a> {

    pub resource_map: &'a ResourceMap,
    pub clear_resource_borrows: bool,
    pub intrinsics: &'a mut BTreeSet<Intrinsic>,
    pub valid_lifting_optimization: bool,
    pub sizes: &'a SizeAlign,
    pub err: ErrHandling,
    pub tmp: usize,
    pub src: Source,
    pub block_storage: Vec<Source>,
    pub blocks: Vec<(String, Vec<String>)>,
    pub params: Vec<String>,
    pub memory: Option<&'a String>,
    pub realloc: Option<&'a String>,
    pub post_return: Option<&'a String>,
    pub tracing_prefix: &'a String,
    pub tracing_enabled: bool,
    pub encoding: StringEncoding,
    pub callee: &'a str,
    pub callee_resource_dynamic: bool,
    pub resolve: &'a Resolve,
    pub requires_async_porcelain: bool,
    pub is_async: bool,
    pub iface_name: Option<&'a str>,
    pub asmjs: bool,
    pub component_state: Option<FunctionBindgenComponentState>,
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

resource_map: &'a ResourceMap

Mapping of resources for types that have corresponding definitions locally

clear_resource_borrows: bool

Whether current resource borrows need to be deactivated

intrinsics: &'a mut BTreeSet<Intrinsic>

Set of intrinsics

valid_lifting_optimization: bool

Whether to perform valid lifting optimization

sizes: &'a SizeAlign

Sizes and alignments for sub elements

err: ErrHandling

Method of error handling

tmp: usize

Temporary values

src: Source

Source code of the function

block_storage: Vec<Source>

Block storage

blocks: Vec<(String, Vec<String>)>

Blocks of the function

params: Vec<String>

Parameters of the function

memory: Option<&'a String>

Memory variable

realloc: Option<&'a String>

Realloc function name

post_return: Option<&'a String>

Post return function name

tracing_prefix: &'a String

Prefix to use when printing tracing information

tracing_enabled: bool

Whether tracing is enabled

encoding: StringEncoding

Method if string encoding

callee: &'a str

Callee of the function

callee_resource_dynamic: bool

Whether the callee is dynamic (i.e. has multiple operands)

resolve: &'a Resolve

The [wit_bindgen::Resolve] containing extracted WIT information

requires_async_porcelain: bool

Whether the function requires async porcelain

In the case of an import this likely implies the use of JSPI and in the case of an export this is simply code generation metadata.

is_async: bool

Whether the function is guest async lifted (i.e. WASI P3)

iface_name: Option<&'a str>

Interface name

asmjs: bool

Whether the callee was transpiled from Wasm to JS (asm.js) and thus needs shimming for i64

component_state: Option<FunctionBindgenComponentState>

Component state generated from processing a component.

This information is normally accessible via producing/having access to a wasmtime_environ::component::Component), and is required for some bindgen instructions.

If you are performing bindgen aganist a dummy module, you may omit this field, but if processing has been performed on the component, and this state is available at time of generation for this function, provide this information (normally found in [CanonicalOptions]s)

Implementations

impl<'a> FunctionBindgen<'a>

pub fn builder() -> FunctionBindgenBuilder<'a>

Create an instance of FunctionBindgen using the builder syntax

Trait Implementations

impl Bindgen for FunctionBindgen<'_>

fn sizes(&self) -> &SizeAlign

Get the sizes and alignment for a given structure

fn push_block(&mut self)

Push a new block of code

fn finish_block(&mut self, operands: &mut Vec<String>)

Finish a block of code

fn return_pointer( &mut self, _size: ArchitectureSize, _align: Alignment, ) -> String

Output the return pointer

fn is_list_canonical(&self, resolve: &Resolve, elem_ty: &Type) -> bool

Check whether a list of the given element type can be represented as a builtni JS type

Arguments

• resolve - the Resolve that might be used to resolve nested types (i.e. [Type::TypeId])
• elem_ty - the Type of the element stored in the list

type Operand = String

The intermediate type for fragments of code for this type.

fn emit( &mut self, resolve: &Resolve, inst: &Instruction<'_>, operands: &mut Vec<String>, results: &mut Vec<String>, )

Emit code to implement the given instruction.