//! Implementation of "inlining" a component into a flat list of initializers.

//!

//! After the first phase of compiling a component we're left with a single

//! root `Translation` for the original component along with a "static" list of

//! child components. Each `Translation` has a list of `LocalInitializer` items

//! inside of it which is a primitive representation of how the component

//! should be constructed with effectively one initializer per item in the

//! index space of a component. This "local initializer" list would be

//! relatively inefficient to process at runtime and more importantly doesn't

//! convey enough information to understand what trampolines need to be

//! compiled or what fused adapters need to be generated. This consequently is

//! the motivation for this file.

//!

//! The second phase of compilation, inlining here, will in a sense interpret

//! the initializers, at compile time, into a new list of `GlobalInitializer` entries

//! which are a sort of "global initializer". The generated `GlobalInitializer` is

//! much more specific than the `LocalInitializer` and additionally far fewer

//! `GlobalInitializer` structures are generated (in theory) than there are local

//! initializers.

//!

//! The "inlining" portion of the name of this module indicates how the

//! instantiation of a component is interpreted as calling a function. The

//! function's arguments are the imports provided to the instantiation of a

//! component, and further nested function calls happen on a stack when a

//! nested component is instantiated. The inlining then refers to how this

//! stack of instantiations is flattened to one list of `GlobalInitializer`

//! entries to represent the process of instantiating a component graph,

//! similar to how function inlining removes call instructions and creates one

//! giant function for a call graph. Here there are no inlining heuristics or

//! anything like that, we simply inline everything into the root component's

//! list of initializers.

//!

//! Another primary task this module performs is a form of dataflow analysis

//! to represent items in each index space with their definition rather than

//! references of relative indices. These definitions (all the `*Def` types in

//! this module) are not local to any one nested component and instead

//! represent state available at runtime tracked in the final `Component`

//! produced.

//!

//! With all this pieced together the general idea is relatively

//! straightforward. All of a component's initializers are processed in sequence

//! where instantiating a nested component pushes a "frame" onto a stack to

//! start executing and we resume at the old one when we're done. Items are

//! tracked where they come from and at the end after processing only the

//! side-effectful initializers are emitted to the `GlobalInitializer` list in the

//! final `Component`.

use crate::component::translate::*;

use crate::{EntityType, Memory};

use core::str::FromStr;

use std::borrow::Cow;

use wasmparser::component_types::{ComponentAnyTypeId, ComponentCoreModuleTypeId};

pub(super) fn run(

    types: &mut ComponentTypesBuilder,

    result: &Translation<'_>,

    nested_modules: &PrimaryMap<StaticModuleIndex, ModuleTranslation<'_>>,

    nested_components: &PrimaryMap<StaticComponentIndex, Translation<'_>>,

) -> Result<dfg::ComponentDfg> {

    let mut inliner = Inliner {

        nested_modules,

        nested_components,

        result: Default::default(),

        import_path_interner: Default::default(),

        runtime_instances: PrimaryMap::default(),

    };

    let index = RuntimeComponentInstanceIndex::from_u32(0);

    // The initial arguments to the root component are all host imports. This

    // means that they're all using the `ComponentItemDef::Host` variant. Here

    // an `ImportIndex` is allocated for each item and then the argument is

    // recorded.

    //

    // Note that this is represents the abstract state of a host import of an

    // item since we don't know the precise structure of the host import.

    let mut args = HashMap::with_capacity(result.exports.len());

    let mut path = Vec::new();

    types.resources_mut().set_current_instance(index);

    let types_ref = result.types_ref();

    for init in result.initializers.iter() {

        let (name, ty) = match *init {

            LocalInitializer::Import(name, ty) => (name, ty),

            _ => continue,

        };

        // Before `convert_component_entity_type` below all resource types

        // introduced by this import need to be registered and have indexes

        // assigned to them. Any fresh new resource type referred to by imports

        // is a brand new introduction of a resource which needs to have a type

        // allocated to it, so new runtime imports are injected for each

        // resource along with updating the `imported_resources` map.

        let index = inliner.result.import_types.next_key();

        types.resources_mut().register_component_entity_type(

            &types_ref,

            ty,

            &mut path,

            &mut |path| {

                let index = inliner.runtime_import(&ImportPath {

                    index,

                    path: path.iter().copied().map(Into::into).collect(),

                });

                inliner.result.imported_resources.push(index)

            },

        );

        // With resources all taken care of it's now possible to convert this

        // into Wasmtime's type system.

        let ty = types.convert_component_entity_type(types_ref, ty)?;

        // Imports of types that aren't resources are not required to be

        // specified by the host since it's just for type information within

        // the component.

        if let TypeDef::Interface(_) = ty {

            continue;

        }

        let index = inliner.result.import_types.push((

            name.name.to_string(),

            ComponentExtern {

                ty,

                data: ComponentExternData::new(name),

            },

        ));

        let path = ImportPath::root(index);

        args.insert(name.name, ComponentItemDef::from_import(path, ty)?);

    }

    // This will run the inliner to completion after being seeded with the

    // initial frame. When the inliner finishes it will return the exports of

    // the root frame which are then used for recording the exports of the

    // component.

    inliner.result.num_runtime_component_instances += 1;

    let frame = InlinerFrame::new(index, result, ComponentClosure::default(), args, None);

    let resources_snapshot = types.resources_mut().clone();

    let mut frames = vec![(frame, resources_snapshot)];

    let exports = inliner.run(types, &mut frames)?;

    assert!(frames.is_empty());

    let mut export_map = Default::default();

    for (name, (def, data)) in exports {

        let data = ComponentExternData::new(data);

        inliner.record_export(name, def, data, types, &mut export_map)?;

    }

    inliner.result.exports = export_map;

    inliner.result.num_future_tables = types.num_future_tables();

    inliner.result.num_stream_tables = types.num_stream_tables();

    inliner.result.num_error_context_tables = types.num_error_context_tables();

    Ok(inliner.result)

}

struct Inliner<'a> {

    /// The list of static modules that were found during initial translation of

    /// the component.

    ///

    /// This is used during the instantiation of these modules to ahead-of-time

    /// order the arguments precisely according to what the module is defined as

    /// needing which avoids the need to do string lookups or permute arguments

    /// at runtime.

    nested_modules: &'a PrimaryMap<StaticModuleIndex, ModuleTranslation<'a>>,

    /// The list of static components that were found during initial translation of

    /// the component.

    ///

    /// This is used when instantiating nested components to push a new

    /// `InlinerFrame` with the `Translation`s here.

    nested_components: &'a PrimaryMap<StaticComponentIndex, Translation<'a>>,

    /// The final `Component` that is being constructed and returned from this

    /// inliner.

    result: dfg::ComponentDfg,

    // Maps used to "intern" various runtime items to only save them once at

    // runtime instead of multiple times.

    import_path_interner: HashMap<ImportPath<'a>, RuntimeImportIndex>,

    /// Origin information about where each runtime instance came from

    runtime_instances: PrimaryMap<dfg::InstanceId, InstanceModule>,

}

/// A "stack frame" as part of the inlining process, or the progress through

/// instantiating a component.

///

/// All instantiations of a component will create an `InlinerFrame` and are

/// incrementally processed via the `initializers` list here. Note that the

/// inliner frames are stored on the heap to avoid recursion based on user

/// input.

struct InlinerFrame<'a> {

    instance: RuntimeComponentInstanceIndex,

    /// The remaining initializers to process when instantiating this component.

    initializers: std::slice::Iter<'a, LocalInitializer<'a>>,

    /// The component being instantiated.

    translation: &'a Translation<'a>,

    /// The "closure arguments" to this component, or otherwise the maps indexed

    /// by `ModuleUpvarIndex` and `ComponentUpvarIndex`. This is created when

    /// a component is created and stored as part of a component's state during

    /// inlining.

    closure: ComponentClosure<'a>,

    /// The arguments to the creation of this component.

    ///

    /// At the root level these are all imports from the host and between

    /// components this otherwise tracks how all the arguments are defined.

    args: HashMap<&'a str, ComponentItemDef<'a>>,

    // core wasm index spaces

    funcs: PrimaryMap<FuncIndex, (ModuleInternedTypeIndex, dfg::CoreDef)>,

    memories: PrimaryMap<MemoryIndex, dfg::CoreExport<EntityIndex>>,

    tables: PrimaryMap<TableIndex, dfg::CoreExport<EntityIndex>>,

    globals: PrimaryMap<GlobalIndex, dfg::CoreExport<EntityIndex>>,

    tags: PrimaryMap<TagIndex, dfg::CoreExport<EntityIndex>>,

    modules: PrimaryMap<ModuleIndex, ModuleDef<'a>>,

    // component model index spaces

    component_funcs: PrimaryMap<ComponentFuncIndex, ComponentFuncDef<'a>>,

    module_instances: PrimaryMap<ModuleInstanceIndex, ModuleInstanceDef<'a>>,

    component_instances: PrimaryMap<ComponentInstanceIndex, ComponentInstanceDef<'a>>,

    components: PrimaryMap<ComponentIndex, ComponentDef<'a>>,

    /// The type of instance produced by completing the instantiation of this

    /// frame.

    ///

    /// This is a wasmparser-relative piece of type information which is used to

    /// register resource types after instantiation has completed.

    ///

    /// This is `Some` for all subcomponents and `None` for the root component.

    instance_ty: Option<ComponentInstanceTypeId>,

}

/// "Closure state" for a component which is resolved from the `ClosedOverVars`

/// state that was calculated during translation.

//

// FIXME: this is cloned quite a lot and given the internal maps if this is a

// perf issue we may want to `Rc` these fields. Note that this is only a perf

// hit at compile-time though which we in general don't pay too much

// attention to.

#[derive(Default, Clone)]

struct ComponentClosure<'a> {

    modules: PrimaryMap<ModuleUpvarIndex, ModuleDef<'a>>,

    components: PrimaryMap<ComponentUpvarIndex, ComponentDef<'a>>,

}

/// Representation of a "path" into an import.

///

/// Imports from the host at this time are one of three things:

///

/// * Functions

/// * Core wasm modules

/// * "Instances" of these three items

///

/// The "base" values are functions and core wasm modules, but the abstraction

/// of an instance allows embedding functions/modules deeply within other

/// instances. This "path" represents optionally walking through a host instance

/// to get to the final desired item. At runtime instances are just maps of

/// values and so this is used to ensure that we primarily only deal with

/// individual functions and modules instead of synthetic instances.

#[derive(Clone, PartialEq, Hash, Eq)]

struct ImportPath<'a> {

    index: ImportIndex,

    path: Vec<Cow<'a, str>>,

}

/// Representation of all items which can be defined within a component.

///

/// This is the "value" of an item defined within a component and is used to

/// represent both imports and exports.

#[derive(Clone)]

enum ComponentItemDef<'a> {

    Component(ComponentDef<'a>),

    Instance(ComponentInstanceDef<'a>),

    Func(ComponentFuncDef<'a>),

    Module(ModuleDef<'a>),

    Type(TypeDef),

}

#[derive(Clone)]

enum ModuleDef<'a> {

    /// A core wasm module statically defined within the original component.

    ///

    /// The `StaticModuleIndex` indexes into the `static_modules` map in the

    /// `Inliner`.

    Static(StaticModuleIndex, ComponentCoreModuleTypeId),

    /// A core wasm module that was imported from the host.

    Import(ImportPath<'a>, TypeModuleIndex),

}

// Note that unlike all other `*Def` types which are not allowed to have local

// indices this type does indeed have local indices. That is represented with

// the lack of a `Clone` here where once this is created it's never moved across

// components because module instances always stick within one component.

enum ModuleInstanceDef<'a> {

    /// A core wasm module instance was created through the instantiation of a

    /// module.

    ///

    /// The `RuntimeInstanceIndex` was the index allocated as this was the

    /// `n`th instantiation and the `ModuleIndex` points into an

    /// `InlinerFrame`'s local index space.

    Instantiated(dfg::InstanceId, ModuleIndex),

    /// A "synthetic" core wasm module which is just a bag of named indices.

    ///

    /// Note that this can really only be used for passing as an argument to

    /// another module's instantiation and is used to rename arguments locally.

    Synthetic(&'a HashMap<&'a str, EntityIndex>),

}

#[derive(Clone)]

enum ComponentFuncDef<'a> {

    /// A compile-time builtin intrinsic.

    UnsafeIntrinsic(UnsafeIntrinsic),

    /// A host-imported component function.

    Import(ImportPath<'a>),

    /// A core wasm function was lifted into a component function.

    Lifted {

        /// The component function type.

        ty: TypeFuncIndex,

        /// The core Wasm function.

        func: dfg::CoreDef,

        /// Canonical options.

        options: AdapterOptions,

    },

}

#[derive(Clone)]

enum ComponentInstanceDef<'a> {

    /// The `__wasmtime_intrinsics` instance that exports all of our

    /// compile-time builtin intrinsics.

    Intrinsics,

    /// A host-imported instance.

    ///

    /// This typically means that it's "just" a map of named values. It's not

    /// actually supported to take a `wasmtime::component::Instance` and pass it

    /// to another instance at this time.

    Import(ImportPath<'a>, TypeComponentInstanceIndex),

    /// A concrete map of values.

    ///

    /// This is used for both instantiated components as well as "synthetic"

    /// components. This variant can be used for both because both are

    /// represented by simply a bag of items within the entire component

    /// instantiation process.

    //

    // FIXME: same as the issue on `ComponentClosure` where this is cloned a lot

    // and may need `Rc`.

    Items(

        IndexMap<&'a str, (ComponentItemDef<'a>, wasmparser::ComponentExternName<'a>)>,

        TypeComponentInstanceIndex,

    ),

}

#[derive(Clone)]

struct ComponentDef<'a> {

    index: StaticComponentIndex,

    closure: ComponentClosure<'a>,

}

impl<'a> Inliner<'a> {

    /// Symbolically instantiates a component using the type information and

    /// `frames` provided.

    ///

    /// The `types` provided is the type information for the entire component

    /// translation process. This is a distinct output artifact separate from

    /// the component metadata.

    ///

    /// The `frames` argument is storage to handle a "call stack" of components

    /// instantiating one another. The youngest frame (last element) of the

    /// frames list is a component that's currently having its initializers

    /// processed. The second element of each frame is a snapshot of the

    /// resource-related information just before the frame was translated. For

    /// more information on this snapshotting see the documentation on

    /// `ResourcesBuilder`.

    fn run(

        &mut self,

        types: &mut ComponentTypesBuilder,

        frames: &mut Vec<(InlinerFrame<'a>, ResourcesBuilder)>,

    ) -> Result<IndexMap<&'a str, (ComponentItemDef<'a>, wasmparser::ComponentExternName<'a>)>>

    {

        // This loop represents the execution of the instantiation of a

        // component. This is an iterative process which is finished once all

        // initializers are processed. Currently this is modeled as an infinite

        // loop which drives the top-most iterator of the `frames` stack

        // provided as an argument to this function.

        loop {

            let (frame, _) = frames.last_mut().unwrap();

            types.resources_mut().set_current_instance(frame.instance);

            match frame.initializers.next() {

                // Process the initializer and if it started the instantiation

                // of another component then we push that frame on the stack to

                // continue onwards.

                Some(init) => match self.initializer(frames, types, init)? {

                    Some(new_frame) => {

                        frames.push((new_frame, types.resources_mut().clone()));

                    }

                    None => {}

                },

                // If there are no more initializers for this frame then the

                // component it represents has finished instantiation. The

                // exports of the component are collected and then the entire

                // frame is discarded. The exports are then either pushed in the

                // parent frame, if any, as a new component instance or they're

                // returned from this function for the root set of exports.

                None => {

                    let exports = frame

                        .translation

                        .exports

                        .iter()

                        .map(|(name, (item, data))| Ok((*name, (frame.item(*item, types)?, *data))))

                        .collect::<Result<_>>()?;

                    let instance_ty = frame.instance_ty;

                    let (_, snapshot) = frames.pop().unwrap();

                    *types.resources_mut() = snapshot;

                    match frames.last_mut() {

                        Some((parent, _)) => {

                            parent.finish_instantiate(exports, instance_ty.unwrap(), types)?;

                        }

                        None => break Ok(exports),

                    }

                }

            }

        }

    }

    fn initializer(

        &mut self,

        frames: &mut Vec<(InlinerFrame<'a>, ResourcesBuilder)>,

        types: &mut ComponentTypesBuilder,

        initializer: &'a LocalInitializer,

    ) -> Result<Option<InlinerFrame<'a>>> {

        use LocalInitializer::*;

        let (frame, _) = frames.last_mut().unwrap();

        match initializer {

            // When a component imports an item the actual definition of the

            // item is looked up here (not at runtime) via its name. The

            // arguments provided in our `InlinerFrame` describe how each

            // argument was defined, so we simply move it from there into the

            // correct index space.

            //

            // Note that for the root component this will add `*::Import` items

            // but for sub-components this will do resolution to connect what

            // was provided as an import at the instantiation-site to what was

            // needed during the component's instantiation.

            Import(name, ty) => {

                let arg = match frame.args.get(name.name) {

                    Some(arg) => arg,

                    // Not all arguments need to be provided for instantiation,

                    // namely the root component in Wasmtime doesn't require

                    // structural type imports to be satisfied. These type

                    // imports are relevant for bindings generators and such but

                    // as a runtime there's not really a definition to fit in.

                    //

                    // If no argument was provided for `name` then it's asserted

                    // that this is a type import and additionally it's not a

                    // resource type import (which indeed must be provided). If

                    // all that passes then this initializer is effectively

                    // skipped.

                    None => {

                        match ty {

                            ComponentEntityType::Type {

                                created: ComponentAnyTypeId::Resource(_),

                                ..

                            } => unreachable!(),

                            ComponentEntityType::Type { .. } => {}

                            _ => unreachable!(),

                        }

                        return Ok(None);

                    }

                };

                // Next resource types need to be handled. For example if a

                // resource is imported into this component then it needs to be

                // assigned a unique table to provide the isolation guarantees

                // of resources (this component's table is shared with no

                // others). Here `register_component_entity_type` will find

                // imported resources and then `lookup_resource` will find the

                // resource within `arg` as necessary to lookup the original

                // true definition of this resource.

                //

                // This is what enables tracking true resource origins

                // throughout component translation while simultaneously also

                // tracking unique tables for each resource in each component.

                let mut path = Vec::new();

                let (resources, types) = types.resources_mut_and_types();

                resources.register_component_entity_type(

                    &frame.translation.types_ref(),

                    *ty,

                    &mut path,

                    &mut |path| arg.lookup_resource(path, types),

                );

                // And now with all the type information out of the way the

                // `arg` definition is moved into its corresponding index space.

                frame.push_item(arg.clone());

            }

            IntrinsicsImport => {

                frame

                    .component_instances

                    .push(ComponentInstanceDef::Intrinsics);

            }

            // Lowering a component function to a core wasm function is

            // generally what "triggers compilation". Here various metadata is

            // recorded and then the final component gets an initializer

            // recording the lowering.

            //

            // NB: at this time only lowered imported functions are supported.

            Lower {

                func,

                options,

                lower_ty,

            } => {

                let lower_ty =

                    types.convert_component_func_type(frame.translation.types_ref(), *lower_ty)?;

                let options_lower = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let lower_core_type = options_lower.core_type;

                let func = match &frame.component_funcs[*func] {

                    // If this component function was originally a host import

                    // then this is a lowered host function which needs a

                    // trampoline to enter WebAssembly. That's recorded here

                    // with all relevant information.

                    ComponentFuncDef::Import(path) => {

                        let import = self.runtime_import(path);

                        let options = self.canonical_options(options_lower);

                        let index = self.result.trampolines.push((

                            lower_core_type,

                            dfg::Trampoline::LowerImport {

                                import,

                                options,

                                lower_ty,

                            },

                        ));

                        dfg::CoreDef::Trampoline(index)

                    }

                    // Lowering a lifted function means that a "fused adapter"

                    // was just identified.

                    //

                    // Metadata about this fused adapter is recorded in the

                    // `Adapters` output of this compilation pass. Currently the

                    // implementation of fused adapters is to generate a core

                    // wasm module which is instantiated with relevant imports

                    // and the exports are used as the fused adapters. At this

                    // time we don't know when precisely the instance will be

                    // created but we do know that the result of this will be an

                    // export from a previously-created instance.

                    //

                    // To model this the result of this arm is a

                    // `CoreDef::Export`. The actual indices listed within the

                    // export are "fake indices" in the sense of they're not

                    // resolved yet. This resolution will happen at a later

                    // compilation phase. Any usages of the `CoreDef::Export`

                    // here will be detected and rewritten to an actual runtime

                    // instance created.

                    //

                    // The `instance` field of the `CoreExport` has a marker

                    // which indicates that it's a fused adapter. The `item` is

                    // a function where the function index corresponds to the

                    // `adapter_idx` which contains the metadata about this

                    // adapter being created. The metadata is used to learn

                    // about the dependencies and when the adapter module can

                    // be instantiated.

                    ComponentFuncDef::Lifted {

                        ty: lift_ty,

                        func,

                        options: options_lift,

                    } => {

                        let adapter_idx = self.result.adapters.push(Adapter {

                            lift_ty: *lift_ty,

                            lift_options: options_lift.clone(),

                            lower_ty,

                            lower_options: options_lower,

                            func: func.clone(),

                        });

                        dfg::CoreDef::Adapter(adapter_idx)

                    }

                    ComponentFuncDef::UnsafeIntrinsic(intrinsic) => {

                        dfg::CoreDef::UnsafeIntrinsic(options.core_type, *intrinsic)

                    }

                };

                frame.funcs.push((lower_core_type, func));

            }

            // Lifting a core wasm function is relatively easy for now in that

            // some metadata about the lifting is simply recorded. This'll get

            // plumbed through to exports or a fused adapter later on.

            Lift(ty, func, options) => {

                let ty = types.convert_component_func_type(frame.translation.types_ref(), *ty)?;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let func = frame.funcs[*func].1.clone();

                frame

                    .component_funcs

                    .push(ComponentFuncDef::Lifted { ty, func, options });

            }

            // A new resource type is being introduced, so it's recorded as a

            // brand new resource in the final `resources` array. Additionally

            // for now resource introductions are considered side effects to

            // know when to register their destructors so that's recorded as

            // well.

            //

            // Note that this has the effect of when a component is instantiated

            // twice it will produce unique types for the resources from each

            // instantiation. That's the intended runtime semantics and

            // implementation here, however.

            Resource(ty, rep, dtor) => {

                let idx = self.result.resources.push(dfg::Resource {

                    rep: *rep,

                    dtor: dtor.map(|i| frame.funcs[i].1.clone()),

                    instance: frame.instance,

                });

                self.result

                    .side_effects

                    .push(dfg::SideEffect::Resource(idx));

                // Register with type translation that all future references to

                // `ty` will refer to `idx`.

                //

                // Note that this registration information is lost when this

                // component finishes instantiation due to the snapshotting

                // behavior in the frame processing loop above. This is also

                // intended, though, since `ty` can't be referred to outside of

                // this component.

                let idx = self.result.resource_index(idx);

                types.resources_mut().register_resource(ty.resource(), idx);

            }

            // Resource-related intrinsics are generally all the same.

            // Wasmparser type information is converted to wasmtime type

            // information and then new entries for each intrinsic are recorded.

            ResourceNew(id, ty) => {

                let id = types.resource_id(id.resource());

                let index = self.result.trampolines.push((

                    *ty,

                    dfg::Trampoline::ResourceNew {

                        instance: frame.instance,

                        ty: id,

                    },

                ));

                frame.funcs.push((*ty, dfg::CoreDef::Trampoline(index)));

            }

            ResourceRep(id, ty) => {

                let id = types.resource_id(id.resource());

                let index = self.result.trampolines.push((

                    *ty,

                    dfg::Trampoline::ResourceRep {

                        instance: frame.instance,

                        ty: id,

                    },

                ));

                frame.funcs.push((*ty, dfg::CoreDef::Trampoline(index)));

            }

            ResourceDrop(id, ty) => {

                let id = types.resource_id(id.resource());

                let index = self.result.trampolines.push((

                    *ty,

                    dfg::Trampoline::ResourceDrop {

                        instance: frame.instance,

                        ty: id,

                    },

                ));

                frame.funcs.push((*ty, dfg::CoreDef::Trampoline(index)));

            }

            BackpressureInc { func } => {

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::BackpressureInc {

                        instance: frame.instance,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            BackpressureDec { func } => {

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::BackpressureDec {

                        instance: frame.instance,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            TaskReturn { result, options } => {

                let results = result

                    .iter()

                    .map(|ty| types.valtype(frame.translation.types_ref(), ty))

                    .collect::<Result<_>>()?;

                let results = types.new_tuple_type(results);

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::TaskReturn {

                        instance: frame.instance,

                        results,

                        options,

                    },

                ));

                frame.funcs.push((func, dfg::CoreDef::Trampoline(index)));

            }

            TaskCancel { func } => {

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::TaskCancel {

                        instance: frame.instance,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            WaitableSetNew { func } => {

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::WaitableSetNew {

                        instance: frame.instance,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            WaitableSetWait { options } => {

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::WaitableSetWait {

                        instance: frame.instance,

                        options,

                    },

                ));

                frame.funcs.push((func, dfg::CoreDef::Trampoline(index)));

            }

            WaitableSetPoll { options } => {

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::WaitableSetPoll {

                        instance: frame.instance,

                        options,

                    },

                ));

                frame.funcs.push((func, dfg::CoreDef::Trampoline(index)));

            }

            WaitableSetDrop { func } => {

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::WaitableSetDrop {

                        instance: frame.instance,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            WaitableJoin { func } => {

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::WaitableJoin {

                        instance: frame.instance,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            SubtaskDrop { func } => {

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::SubtaskDrop {

                        instance: frame.instance,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            SubtaskCancel { func, async_ } => {

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::SubtaskCancel {

                        instance: frame.instance,

                        async_: *async_,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            StreamNew { ty, func } => {

                let InterfaceType::Stream(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::StreamNew {

                        instance: frame.instance,

                        ty,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            StreamRead { ty, options } => {

                let InterfaceType::Stream(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::StreamRead {

                        instance: frame.instance,

                        ty,

                        options,

                    },

                ));

                frame.funcs.push((func, dfg::CoreDef::Trampoline(index)));

            }

            StreamWrite { ty, options } => {

                let InterfaceType::Stream(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::StreamWrite {

                        instance: frame.instance,

                        ty,

                        options,

                    },

                ));

                frame.funcs.push((func, dfg::CoreDef::Trampoline(index)));

            }

            StreamCancelRead { ty, func, async_ } => {

                let InterfaceType::Stream(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::StreamCancelRead {

                        instance: frame.instance,

                        ty,

                        async_: *async_,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            StreamCancelWrite { ty, func, async_ } => {

                let InterfaceType::Stream(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::StreamCancelWrite {

                        instance: frame.instance,

                        ty,

                        async_: *async_,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            StreamDropReadable { ty, func } => {

                let InterfaceType::Stream(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::StreamDropReadable {

                        instance: frame.instance,

                        ty,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            StreamDropWritable { ty, func } => {

                let InterfaceType::Stream(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::StreamDropWritable {

                        instance: frame.instance,

                        ty,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            FutureNew { ty, func } => {

                let InterfaceType::Future(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::FutureNew {

                        instance: frame.instance,

                        ty,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            FutureRead { ty, options } => {

                let InterfaceType::Future(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::FutureRead {

                        instance: frame.instance,

                        ty,

                        options,

                    },

                ));

                frame.funcs.push((func, dfg::CoreDef::Trampoline(index)));

            }

            FutureWrite { ty, options } => {

                let InterfaceType::Future(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::FutureWrite {

                        instance: frame.instance,

                        ty,

                        options,

                    },

                ));

                frame.funcs.push((func, dfg::CoreDef::Trampoline(index)));

            }

            FutureCancelRead { ty, func, async_ } => {

                let InterfaceType::Future(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::FutureCancelRead {

                        instance: frame.instance,

                        ty,

                        async_: *async_,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            FutureCancelWrite { ty, func, async_ } => {

                let InterfaceType::Future(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::FutureCancelWrite {

                        instance: frame.instance,

                        ty,

                        async_: *async_,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            FutureDropReadable { ty, func } => {

                let InterfaceType::Future(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::FutureDropReadable {

                        instance: frame.instance,

                        ty,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            FutureDropWritable { ty, func } => {

                let InterfaceType::Future(ty) =

                    types.defined_type(frame.translation.types_ref(), *ty)?

                else {

                    unreachable!()

                };

                let index = self.result.trampolines.push((

                    *func,

                    dfg::Trampoline::FutureDropWritable {

                        instance: frame.instance,

                        ty,

                    },

                ));

                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));

            }

            ErrorContextNew { options } => {

                let ty = types.error_context_table_type()?;

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::ErrorContextNew {

                        instance: frame.instance,

                        ty,

                        options,

                    },

                ));

                frame.funcs.push((func, dfg::CoreDef::Trampoline(index)));

            }

            ErrorContextDebugMessage { options } => {

                let ty = types.error_context_table_type()?;

                let func = options.core_type;

                let options = self.adapter_options(frames, types, options);

                let (frame, _) = frames.last_mut().unwrap();

                let options = self.canonical_options(options);

                let index = self.result.trampolines.push((

                    func,

                    dfg::Trampoline::ErrorContextDebugMessage {