Enum FunctionBinding

pub enum FunctionBinding {
    Import(ImportBinding),
    Export(ExportBinding),
}

Variants

Import(ImportBinding)

Export(ExportBinding)

Implementations

impl FunctionBinding

pub fn is_expressible_in_js_without_webidl_bindings( &self, module: &Module, wb: &WebidlBindings, ) -> bool

In the context of a JS embedder that does not implement the Web IDL bindings proposal, are this binding’s ingoing and outgoing conversions losslessly expressible with the default conversions of the WebAssembly JavaScript interface and the ECMAScript bindings for Web IDL?

This is primarily a question that is only relevant to polyfills for Web IDL bindings, such as wasm-bindgen.

For both incoming and outgoing values, the conversions are not expressible if each value is referenced more than once in the binding map, or the values are referenced out of order. Failure to meet this criteria would result in swapped, garbage, extra, or not enough parameters/results.

In addition to the arity and usage requirements, each value’s type must also be trivially convertible. This property depends on whether the value is incoming or outgoing.

Outgoing Values

When passing outgoing Wasm values to Web IDL, first they are converted to JS values via the ToJSValue algorithm defined by the WebAssembly JavaScript interface. Next, these JS values then they are converted into Web IDL values via Web IDL’s ECMAScript type mapping.

+------------+                                 +----------+                                        +---------------+
| Wasm value | ---WebAssembly-JS-interface---> | JS value | ---ECMAScript-bindings-for-Web-IDL---> | Web IDL value |
+------------+                                 +----------+                                        +---------------+

For outgoing values to be expressible without Web IDL bindings, nor extra glue or conversions, they must be an as operator performing on of the following conversions from a Wasm value type to a Web IDL type:

From Wasm valtype	To Web IDL Type
i32, f32, f64, anyref	any
i32	long, long long, float, unrestricted float, double, unrestricted double
f32	unrestricted float, unrestricted double
f64	unrestricted double

Incoming Values

When passing Web IDL values to Wasm, first they are converted to JS values via the Web IDL’s ECMAScript type mapping, and then those JS values are converted into Wasm values according to the ToWebAssemblyValue algorithm defined by the WebAssembly JavaScript interface.

+---------------+                                         +----------+                                 +---------------+
| Web IDL value |  ---ECMAScript-bindings-for-Web-IDL---> | JS value | ---WebAssembly-JS-interface---> | Web IDL value |
+---------------+                                         +----------+                                 +---------------+

For incoming values to be expressible without Web IDL bindings, nor extra glue or conversions, they must be an incoming binding expression of the form (as (get <i>)) that is performing one of the following conversions from a Web IDL type to a Wasm type:

From Web IDL Type	To Wasm valtype
any	anyref
byte, short, long	i32
byte, octet, short, unsigned short, float, unrestricted float	f32
byte, octet, short, unsigned short, long, unsigned long, float, unrestricted float, double, unrestricted double	f64

Trait Implementations

impl Clone for FunctionBinding

fn clone(&self) -> FunctionBinding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionBinding

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

Formats the value using the given formatter.

impl From<ExportBinding> for FunctionBinding

fn from(a: ExportBinding) -> Self

Converts to this type from the input type.

impl From<ImportBinding> for FunctionBinding

fn from(a: ImportBinding) -> Self

Converts to this type from the input type.

impl FunctionBindingId for FunctionBinding

type Id = Id<FunctionBinding>

impl PartialEq for FunctionBinding

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for FunctionBinding

impl StructuralPartialEq for FunctionBinding