Skip to main content

wit_dylib/
lib.rs

1use std::borrow::Cow;
2use std::collections::{HashMap, HashSet};
3use std::mem;
4use wasm_encoder::{
5    CodeSection, ConstExpr, CustomSection, DataSection, ElementSection, Elements, Encode,
6    EntityType, ExportKind, ExportSection, Function, FunctionSection, GlobalType, ImportSection,
7    MemoryType, Module, NameMap, NameSection, RefType, TableType, TypeSection, ValType,
8};
9use wit_parser::abi::{WasmSignature, WasmType};
10use wit_parser::{
11    Handle, LiftLowerAbi, LiveTypes, ManglingAndAbi, Resolve, ResourceIntrinsic, SizeAlign, Type,
12    TypeDefKind, TypeId, TypeOwner, WasmExport, WasmExportKind, WasmImport, WorldId, WorldItem,
13    WorldKey,
14};
15
16mod async_;
17mod bindgen;
18pub mod metadata;
19pub use crate::async_::AsyncFilterSet;
20pub use crate::metadata::Metadata;
21
22pub const C_HEADER: &'static str = include_str!("../wit_dylib.h");
23
24#[derive(Default, Clone, Debug)]
25#[cfg_attr(feature = "clap", derive(clap::Parser))]
26pub struct DylibOpts {
27    /// The interpreter name to insert into the `WASM_DYLINK_NEEDED` section
28    /// encoded as `dylink.0`.
29    #[cfg_attr(feature = "clap", clap(long, value_name = "name"))]
30    pub interpreter: Option<String>,
31
32    #[cfg_attr(feature = "clap", clap(flatten))]
33    pub async_: AsyncFilterSet,
34
35    /// Where the stack pointer is located in the ABI of the generated dylib.
36    ///
37    /// For WASIp2-and-prior the `global` option should be used, and for
38    /// WASIp3-and-later the `task-context` option should be used.
39    #[cfg_attr(
40        feature = "clap",
41        clap(long, value_name = "loc", default_value = "global")
42    )]
43    pub stack_pointer: StackPointer,
44}
45
46#[derive(Default, Clone, Debug)]
47#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
48pub enum StackPointer {
49    #[default]
50    Global,
51    TaskContext,
52}
53
54pub fn create(resolve: &Resolve, world_id: WorldId, opts: Option<&mut DylibOpts>) -> Vec<u8> {
55    create_with_metadata(resolve, world_id, opts).0
56}
57
58pub fn create_with_metadata(
59    resolve: &Resolve,
60    world_id: WorldId,
61    mut opts: Option<&mut DylibOpts>,
62) -> (Vec<u8>, Metadata) {
63    let mut adapter = Adapter::default();
64    if let Some(opts) = &mut opts {
65        adapter.opts = opts.clone();
66    }
67    let result = adapter.encode(resolve, world_id);
68    if let Some(opts) = &mut opts {
69        **opts = adapter.opts;
70    }
71    (result, adapter.metadata)
72}
73
74#[derive(Default)]
75struct Adapter {
76    types: TypeSection,
77    wasm_type_map: HashMap<(Vec<ValType>, Vec<ValType>), u32>,
78    imports: ImportSection,
79    imports_done: bool,
80    global_index: u32,
81    table_base: Option<u32>,
82    memory_base: Option<u32>,
83    stack_pointer: Option<ImportedStackPointer>,
84    func_index: u32,
85    functions: FunctionSection,
86    exports: ExportSection,
87    code: CodeSection,
88    global_names: NameMap,
89    function_names: NameMap,
90    metadata: Metadata,
91    type_map: HashMap<TypeId, metadata::Type>,
92    resource_map: HashMap<TypeId, usize>,
93    export_resource_map: HashMap<TypeId, usize>,
94    intrinsics: Option<bindgen::WitInterpreterIntrinsics>,
95    sizes: SizeAlign,
96    opts: DylibOpts,
97
98    /// Contents of the element segment of this module, which will start at
99    /// `__table_base`.
100    ///
101    /// Elements of this list are function indices in this module which will be
102    /// placed into the element segment.
103    elem_segment: Vec<u32>,
104}
105
106#[derive(Copy, Clone)]
107enum ImportedStackPointer {
108    Global(u32),
109    TaskContext { get: u32, set: u32 },
110}
111
112#[derive(Default)]
113struct Imports<'a> {
114    wit_imports: Vec<WitImport<'a>>,
115    wit_exports: Vec<WitExport<'a>>,
116}
117
118struct WitImport<'a> {
119    interface: Option<&'a WorldKey>,
120    func: &'a wit_parser::Function,
121    import_index: u32,
122}
123
124struct WitExport<'a> {
125    interface: Option<&'a WorldKey>,
126    func: &'a wit_parser::Function,
127    async_task_return_index: Option<u32>,
128}
129
130/// Represents data for a given `stream<T>` or `future<T>` as referenced by an
131/// imported or exported function by way of its parameter list or result.
132struct PayloadData {
133    /// `{stream|future}.new` import
134    new_elem_index: u32,
135    /// `{stream|future}.read` import
136    read_elem_index: u32,
137    /// `{stream|future}.write` import
138    write_elem_index: u32,
139    /// `{stream|future}.cancel-read` import
140    cancel_read_elem_index: u32,
141    /// `{stream|future}.cancel-write` import
142    cancel_write_elem_index: u32,
143    /// `{stream|future}.drop-readable` import
144    drop_readable_elem_index: u32,
145    /// `{stream|future}.drop-writable` import
146    drop_writable_elem_index: u32,
147    /// Position of this `stream<T>` or `future<T>` in the function's signature
148    /// relative to any other `stream`s or `future`s.  See
149    /// `wit_parser::Function::find_futures_and_streams` for details.
150    ordinal: usize,
151    /// Name of the function with the signature in which this `stream<T>` or
152    /// `future<T>` was found.
153    function: String,
154}
155
156impl Adapter {
157    pub fn encode(&mut self, resolve: &Resolve, world_id: WorldId) -> Vec<u8> {
158        self.sizes.fill(resolve);
159
160        // First define all imports that will go into the wasm module since
161        // they're required to be first in their index spaces anyway. This will
162        // import intrinsics necessary for exported resources, for example, as
163        // well.
164        let imports = self.add_imports(resolve, world_id);
165
166        let mut payload_data = HashMap::new();
167        self.collect_payload_data(resolve, world_id, &mut payload_data);
168
169        self.imports_done = true;
170
171        // Ensure that `cabi_realloc` is reexported from our module to indicate
172        // that our module's allocations are routed through the same
173        // `cabi_realloc` we're importing.
174        let cabi_realloc = self.intrinsics().cabi_realloc;
175        self.exports
176            .export("cabi_realloc", ExportKind::Func, cabi_realloc);
177
178        // Generate/add metadata for all functions that are either imported or
179        // exported.
180        self.bindgen_world(resolve, world_id, &imports, &payload_data);
181
182        // Now that all functions have been learned about the metadata data
183        // segment can be finalized and emitted. Here this additionally invokes
184        // the interpreter initialization function as part of a ctor to ensure
185        // that the interpreter is aware of where metadata ended up in linear
186        // memory.
187        let (metadata_offset, metadata) = self.encode_metadata();
188        let mut ctor = Function::new([]);
189        ctor.instructions().i32_const(metadata_offset as i32);
190        ctor.instructions().global_get(self.memory_base());
191        ctor.instructions().i32_add();
192        ctor.instructions().call(self.intrinsics().initialize);
193        ctor.instructions().end();
194        let ty = self.define_ty([], []);
195        self.define_func("__wasm_call_ctors", ty, ctor, true);
196
197        self.finish(&metadata)
198    }
199
200    fn mangling(
201        &mut self,
202        resolve: &Resolve,
203        interface: Option<&WorldKey>,
204        func: &wit_parser::Function,
205        is_import: bool,
206    ) -> ManglingAndAbi {
207        let abi = if self
208            .opts
209            .async_
210            .is_async(resolve, interface, func, is_import)
211        {
212            LiftLowerAbi::AsyncCallback
213        } else {
214            LiftLowerAbi::Sync
215        };
216        ManglingAndAbi::Legacy(abi)
217    }
218
219    fn resource_intrinsic_mangling(&mut self) -> ManglingAndAbi {
220        ManglingAndAbi::Legacy(LiftLowerAbi::Sync)
221    }
222
223    /// Scan the specified function for any `stream` or `future` types in the
224    /// parameter list or result, importing the necessary intrinsics for each
225    /// one found and inserting them into `data` for later reference.
226    fn collect_payload_data_for_func(
227        &mut self,
228        resolve: &Resolve,
229        interface: Option<&WorldKey>,
230        func: &wit_parser::Function,
231        prefix: &str,
232        data: &mut HashMap<TypeId, PayloadData>,
233    ) {
234        let mut make = |arg_count, kind, ordinal| {
235            let module = format!(
236                "{prefix}{}",
237                interface
238                    .map(|name| resolve.name_world_key(name))
239                    .unwrap_or_else(|| "$root".into())
240            );
241            let function = func.name.clone();
242
243            let import = |me: &mut Self, prefix, name, params, results| {
244                let ty = me.define_ty(params, results);
245                let import = me.import_func(
246                    &module,
247                    &format!("{prefix}[{kind}-{name}-{ordinal}]{function}"),
248                    ty,
249                );
250                me.push_elem(import)
251            };
252
253            let new_elem_index = import(self, "", "new", vec![], vec![ValType::I64]);
254            let read_elem_index = import(
255                self,
256                "[async-lower]",
257                "read",
258                vec![ValType::I32; arg_count],
259                vec![ValType::I32],
260            );
261            let write_elem_index = import(
262                self,
263                "[async-lower]",
264                "write",
265                vec![ValType::I32; arg_count],
266                vec![ValType::I32],
267            );
268            let cancel_read_elem_index = import(
269                self,
270                "",
271                "cancel-read",
272                vec![ValType::I32],
273                vec![ValType::I32],
274            );
275            let cancel_write_elem_index = import(
276                self,
277                "",
278                "cancel-write",
279                vec![ValType::I32],
280                vec![ValType::I32],
281            );
282            let drop_readable_elem_index =
283                import(self, "", "drop-readable", vec![ValType::I32], vec![]);
284            let drop_writable_elem_index =
285                import(self, "", "drop-writable", vec![ValType::I32], vec![]);
286
287            PayloadData {
288                new_elem_index,
289                read_elem_index,
290                write_elem_index,
291                cancel_read_elem_index,
292                cancel_write_elem_index,
293                drop_readable_elem_index,
294                drop_writable_elem_index,
295                ordinal,
296                function,
297            }
298        };
299
300        for (ordinal, ty) in func
301            .find_futures_and_streams(resolve)
302            .into_iter()
303            .enumerate()
304        {
305            match &resolve.types[ty].kind {
306                TypeDefKind::Future(_) => {
307                    data.entry(ty).or_insert_with(|| make(2, "future", ordinal))
308                }
309                TypeDefKind::Stream(_) => {
310                    data.entry(ty).or_insert_with(|| make(3, "stream", ordinal))
311                }
312                _ => unreachable!(),
313            };
314        }
315    }
316
317    fn collect_payload_data(
318        &mut self,
319        resolve: &Resolve,
320        world_id: WorldId,
321        data: &mut HashMap<TypeId, PayloadData>,
322    ) {
323        let world = &resolve.worlds[world_id];
324
325        for (key, import) in world.imports.iter() {
326            match import {
327                WorldItem::Interface { id, .. } => {
328                    for (_, func) in resolve.interfaces[*id].functions.iter() {
329                        self.collect_payload_data_for_func(resolve, Some(key), func, "", data);
330                    }
331                }
332                WorldItem::Type { .. } => {}
333                WorldItem::Function(func) => {
334                    self.collect_payload_data_for_func(resolve, None, func, "", data);
335                }
336            }
337        }
338
339        for (key, export) in world.exports.iter() {
340            match export {
341                WorldItem::Interface { id, .. } => {
342                    for (_, func) in resolve.interfaces[*id].functions.iter() {
343                        self.collect_payload_data_for_func(
344                            resolve,
345                            Some(key),
346                            func,
347                            "[export]",
348                            data,
349                        );
350                    }
351                }
352                WorldItem::Type { .. } => unreachable!(),
353                WorldItem::Function(func) => {
354                    self.collect_payload_data_for_func(resolve, None, func, "[export]", data);
355                }
356            }
357        }
358    }
359
360    fn add_imports<'a>(&mut self, resolve: &'a Resolve, world_id: WorldId) -> Imports<'a> {
361        let mut ret = Imports::default();
362        let world = &resolve.worlds[world_id];
363
364        // First up import everything from the interpreter itself that we're
365        // going to possibly need.
366        self.intrinsics = Some(bindgen::WitInterpreterIntrinsics::new(self));
367
368        // Generate function imports for all world imports, in addition to
369        // intrinsics for all resources imported as well. This will additionally
370        // populate the `Imports` return value with all functions that were
371        // found.
372        for (interface, import) in world.imports.iter() {
373            match import {
374                WorldItem::Interface { id, .. } => {
375                    for (_, func) in resolve.interfaces[*id].functions.iter() {
376                        self.add_imported_func(resolve, Some(interface), func, &mut ret);
377                    }
378                    for (_, ty) in resolve.interfaces[*id].types.iter() {
379                        self.add_imported_type_intrinsics(resolve, Some(interface), *ty);
380                    }
381                }
382                WorldItem::Type { id, .. } => {
383                    self.add_imported_type_intrinsics(resolve, None, *id);
384                }
385                WorldItem::Function(func) => {
386                    self.add_imported_func(resolve, None, func, &mut ret);
387                }
388            }
389        }
390
391        // Exported resources need to have intrinsics imported for manipulation,
392        // so do so here.
393        for (name, export) in world.exports.iter() {
394            match export {
395                WorldItem::Function(func) => {
396                    self.add_imported_func_intrinsics_for_export(resolve, None, func, &mut ret);
397                }
398                WorldItem::Interface { id: export, .. } => {
399                    for (_, ty) in resolve.interfaces[*export].types.iter() {
400                        self.add_imported_type_intrinsics_for_export(resolve, Some(name), *ty);
401                    }
402                    for (_, func) in resolve.interfaces[*export].functions.iter() {
403                        self.add_imported_func_intrinsics_for_export(
404                            resolve,
405                            Some(name),
406                            func,
407                            &mut ret,
408                        );
409                    }
410                }
411                WorldItem::Type { .. } => unreachable!(),
412            }
413        }
414
415        let const_i32_global = GlobalType {
416            val_type: ValType::I32,
417            mutable: false,
418            shared: false,
419        };
420        let mut_i32_global = GlobalType {
421            val_type: ValType::I32,
422            mutable: true,
423            shared: false,
424        };
425
426        self.table_base = Some(self.import_global("env", "__table_base", const_i32_global));
427        self.memory_base = Some(self.import_global("env", "__memory_base", const_i32_global));
428        self.stack_pointer = Some(match self.opts.stack_pointer {
429            StackPointer::Global => ImportedStackPointer::Global(self.import_global(
430                "env",
431                "__stack_pointer",
432                mut_i32_global,
433            )),
434            StackPointer::TaskContext => {
435                let get_ty = self.define_ty([], [ValType::I32]);
436                let set_ty = self.define_ty([ValType::I32], []);
437                ImportedStackPointer::TaskContext {
438                    get: self.import_func("$root", "[context-get-0]", get_ty),
439                    set: self.import_func("$root", "[context-set-0]", set_ty),
440                }
441            }
442        });
443
444        self.imports.import(
445            "env",
446            "memory",
447            EntityType::Memory(MemoryType {
448                minimum: 0,
449                maximum: None,
450                memory64: false,
451                shared: false,
452                page_size_log2: None,
453            }),
454        );
455
456        self.imports.import(
457            "env",
458            "__indirect_function_table",
459            EntityType::Table(TableType {
460                element_type: RefType::FUNCREF,
461                minimum: 0,
462                maximum: None,
463                table64: false,
464                shared: false,
465            }),
466        );
467        ret
468    }
469
470    fn add_imported_func<'a>(
471        &mut self,
472        resolve: &'a Resolve,
473        interface: Option<&'a WorldKey>,
474        func: &'a wit_parser::Function,
475        imports: &mut Imports<'a>,
476    ) {
477        let mangling = self.mangling(resolve, interface, func, true);
478        let (module, name) =
479            resolve.wasm_import_name(mangling, WasmImport::Func { interface, func });
480        let sig = resolve.wasm_signature(mangling.import_variant(), func);
481        let ty = self.define_wasm_sig(sig);
482        let import_index = self.import_func(&module, &name, ty);
483        imports.wit_imports.push(WitImport {
484            func,
485            interface,
486            import_index,
487        });
488    }
489
490    fn add_imported_type_intrinsics<'a>(
491        &mut self,
492        resolve: &Resolve,
493        interface: Option<&'a WorldKey>,
494        id: TypeId,
495    ) {
496        let mangling = self.resource_intrinsic_mangling();
497        let ty = &resolve.types[id];
498        match ty.kind {
499            TypeDefKind::Resource => {
500                let (module, name) = resolve.wasm_import_name(
501                    mangling,
502                    WasmImport::ResourceIntrinsic {
503                        interface,
504                        resource: id,
505                        intrinsic: ResourceIntrinsic::ImportedDrop,
506                    },
507                );
508                let core_ty = self.define_ty([ValType::I32], []);
509                let drop = self.import_func(&module, &name, core_ty);
510                let drop_elem_index = self.push_elem(drop);
511                let resource_index = self.metadata.resources.len();
512                self.metadata.resources.push(metadata::Resource {
513                    id,
514                    interface: interface.map(|i| resolve.name_world_key(i)),
515                    name: ty.name.clone().unwrap(),
516                    drop_elem_index,
517                    new_elem_index: None,
518                    rep_elem_index: None,
519                });
520                let prev = self.resource_map.insert(id, resource_index);
521                assert!(prev.is_none());
522            }
523
524            // No other types with intrinsics at this time (futures/streams are
525            // relative to where they show up in function types).
526            _ => {}
527        }
528    }
529
530    fn add_imported_type_intrinsics_for_export<'a>(
531        &mut self,
532        resolve: &Resolve,
533        interface: Option<&'a WorldKey>,
534        id: TypeId,
535    ) {
536        let ty = &resolve.types[id];
537        let mangling = self.resource_intrinsic_mangling();
538        match ty.kind {
539            TypeDefKind::Resource => {
540                let drop_ty = self.define_ty([ValType::I32], []);
541                let new_rep_ty = self.define_ty([ValType::I32], [ValType::I32]);
542
543                let mut import = |ty, intrinsic| {
544                    let (module, name) = resolve.wasm_import_name(
545                        mangling,
546                        WasmImport::ResourceIntrinsic {
547                            interface,
548                            resource: id,
549                            intrinsic,
550                        },
551                    );
552                    self.import_func(&module, &name, ty)
553                };
554
555                let drop = import(drop_ty, ResourceIntrinsic::ExportedDrop);
556                let new = import(new_rep_ty, ResourceIntrinsic::ExportedNew);
557                let rep = import(new_rep_ty, ResourceIntrinsic::ExportedRep);
558
559                let drop_elem_index = self.push_elem(drop);
560                let new_elem_index = Some(self.push_elem(new));
561                let rep_elem_index = Some(self.push_elem(rep));
562
563                let resource_index = self.metadata.resources.len();
564                self.metadata.resources.push(metadata::Resource {
565                    id,
566                    interface: interface.map(|i| resolve.name_world_key(i)),
567                    name: ty.name.clone().unwrap(),
568                    drop_elem_index,
569                    new_elem_index,
570                    rep_elem_index,
571                });
572
573                // Note that this populates an `export_resource_map` instead of
574                // `resource_map` to ensure that if an interface is both
575                // imported and exported that we don't clobber the import
576                // version here. The clobber here happens later when bindings
577                // are generated for exports.
578                let prev = self.export_resource_map.insert(id, resource_index);
579                assert!(prev.is_none());
580            }
581
582            // No other types with intrinsics at this time (futures/streams
583            // relative to where they are in a function).
584            _ => {}
585        }
586    }
587
588    /// Adds `task.return` imports for async functions, and appends all
589    /// functions to `ret.wit_exports`.
590    fn add_imported_func_intrinsics_for_export<'a>(
591        &mut self,
592        resolve: &Resolve,
593        interface: Option<&'a WorldKey>,
594        func: &'a wit_parser::Function,
595        ret: &mut Imports<'a>,
596    ) {
597        let mangling = self.mangling(resolve, interface, func, false);
598        let async_task_return_index = if mangling.is_async() {
599            let (module, name, sig) =
600                func.task_return_import(resolve, interface, mangling.mangling());
601            let ty = self.define_wasm_sig(sig);
602            Some(self.import_func(&module, &name, ty))
603        } else {
604            None
605        };
606        ret.wit_exports.push(WitExport {
607            interface,
608            func,
609            async_task_return_index,
610        });
611    }
612
613    fn bindgen_world(
614        &mut self,
615        resolve: &Resolve,
616        world_id: WorldId,
617        imports: &Imports<'_>,
618        payload_data: &HashMap<TypeId, PayloadData>,
619    ) {
620        let world = &resolve.worlds[world_id];
621
622        // Build up a map for all types of all imports. This pushes all type
623        // information into the metadata section that the interpreter will end
624        // up learning about.
625        let mut import_types = LiveTypes::default();
626        let mut interface_names = HashMap::new();
627        for (interface, import) in world.imports.iter() {
628            import_types.add_world_item(resolve, import);
629            if let WorldItem::Interface { id, .. } = import {
630                interface_names.insert(*id, interface);
631            }
632        }
633        for (_, export) in world.exports.iter() {
634            match export {
635                WorldItem::Function(func) => import_types.add_func(resolve, func),
636                WorldItem::Interface { .. } => {}
637                WorldItem::Type { .. } => unreachable!(),
638            }
639        }
640        for ty in import_types.iter() {
641            let key = match resolve.types[ty].owner {
642                TypeOwner::Interface(id) => Some(interface_names[&id]),
643                _ => None,
644            };
645            self.register_type(resolve, key, ty, payload_data);
646        }
647
648        // Using the populated type map for imports generate functions to invoke
649        // these imports. Also generate exported functions in the world since
650        // they use imported types as well.
651        for import in imports.wit_imports.iter() {
652            self.bindgen_world_func_import(resolve, import);
653        }
654        for export in imports.wit_exports.iter().filter(|i| i.interface.is_none()) {
655            self.bindgen_world_func_export(resolve, export);
656        }
657
658        // Next handle exported interfaces. This is a bit tricky since an
659        // interface can be both exported and imported. To handle that first the
660        // `type_map` set is pruned to only include imported types required, and
661        // then all exported types are added. Export types skip over all
662        // types present in `self.type_map`, though, since those are already
663        // retained from imports.
664        let to_keep = imported_types_used_by_exported_interfaces(resolve, world_id);
665        self.type_map.retain(|id, _| to_keep.contains(*id));
666        let mut exported_types = LiveTypes::default();
667        let mut export_names = HashMap::new();
668        for (interface, import) in world.exports.iter() {
669            if let WorldItem::Interface { id, .. } = import {
670                exported_types.add_world_item(resolve, import);
671                export_names.insert(*id, interface);
672            }
673        }
674        for (ty, index) in mem::take(&mut self.export_resource_map) {
675            self.resource_map.insert(ty, index);
676        }
677        for ty in exported_types.iter() {
678            if self.type_map.contains_key(&ty) {
679                continue;
680            }
681            let key = match resolve.types[ty].owner {
682                TypeOwner::Interface(id) => Some(export_names[&id]),
683                _ => None,
684            };
685            self.register_type(resolve, key, ty, payload_data);
686
687            if let Some(index) = self.resource_map.get(&ty) {
688                self.bindgen_world_export_resource_dtor(resolve, key.unwrap(), ty, *index);
689            }
690        }
691
692        // With export types all in place now run bindgen for all exported
693        // functions.
694        for export in imports.wit_exports.iter().filter(|i| i.interface.is_some()) {
695            self.bindgen_world_func_export(resolve, export);
696        }
697    }
698
699    /// Push WIT type information into metadata for the interpreter.
700    ///
701    /// This will insert `id` into metadata and build up the interpreter data
702    /// structures for it. The end-result is the population of `self.type_map`
703    /// here.
704    fn register_type(
705        &mut self,
706        resolve: &Resolve,
707        key: Option<&WorldKey>,
708        id: TypeId,
709        payload_data: &HashMap<TypeId, PayloadData>,
710    ) {
711        let ty = &resolve.types[id];
712        let interface = key.map(|key| resolve.name_world_key(key));
713        let name = ty.name.clone();
714        let result = match &ty.kind {
715            TypeDefKind::Record(r) => {
716                let index = self.metadata.records.len();
717                let fields = r
718                    .fields
719                    .iter()
720                    .map(|field| (field.name.clone(), self.lookup_ty(&field.ty)))
721                    .collect();
722                self.metadata.records.push(metadata::Record {
723                    id,
724                    interface,
725                    name: name.unwrap(),
726                    fields,
727                });
728                metadata::Type::Record(index)
729            }
730            TypeDefKind::Flags(t) => {
731                let index = self.metadata.flags.len();
732                let names = t.flags.iter().map(|f| f.name.clone()).collect();
733                self.metadata.flags.push(metadata::Flags {
734                    id,
735                    interface,
736                    name: name.unwrap(),
737                    names,
738                });
739                metadata::Type::Flags(index)
740            }
741            TypeDefKind::Tuple(t) => {
742                let index = self.metadata.tuples.len();
743                let types = t.types.iter().map(|t| self.lookup_ty(t)).collect();
744                self.metadata.tuples.push(metadata::Tuple {
745                    id,
746                    interface,
747                    name,
748                    types,
749                });
750                metadata::Type::Tuple(index)
751            }
752            TypeDefKind::Variant(t) => {
753                let index = self.metadata.variants.len();
754                let cases = t
755                    .cases
756                    .iter()
757                    .map(|c| (c.name.clone(), c.ty.map(|t| self.lookup_ty(&t))))
758                    .collect();
759                self.metadata.variants.push(metadata::Variant {
760                    id,
761                    interface,
762                    name: name.unwrap(),
763                    cases,
764                });
765                metadata::Type::Variant(index)
766            }
767            TypeDefKind::Enum(t) => {
768                let index = self.metadata.enums.len();
769                let names = t.cases.iter().map(|f| f.name.clone()).collect();
770                self.metadata.enums.push(metadata::Enum {
771                    id,
772                    interface,
773                    name: name.unwrap(),
774                    names,
775                });
776                metadata::Type::Enum(index)
777            }
778            TypeDefKind::Option(t) => {
779                let index = self.metadata.options.len();
780                self.metadata.options.push(metadata::WitOption {
781                    id,
782                    interface,
783                    name,
784                    ty: self.lookup_ty(t),
785                });
786                metadata::Type::Option(index)
787            }
788            TypeDefKind::Result(t) => {
789                let index = self.metadata.results.len();
790                self.metadata.results.push(metadata::WitResult {
791                    id,
792                    interface,
793                    name,
794                    ok: t.ok.map(|t| self.lookup_ty(&t)),
795                    err: t.err.map(|t| self.lookup_ty(&t)),
796                });
797                metadata::Type::Result(index)
798            }
799            TypeDefKind::List(t) => {
800                let index = self.metadata.lists.len();
801                self.metadata.lists.push(metadata::List {
802                    id,
803                    interface,
804                    name,
805                    ty: self.lookup_ty(t),
806                });
807                metadata::Type::List(index)
808            }
809            TypeDefKind::FixedLengthList(t, len) => {
810                let index = self.metadata.fixed_length_lists.len();
811                self.metadata
812                    .fixed_length_lists
813                    .push(metadata::FixedLengthList {
814                        id,
815                        interface,
816                        name,
817                        len: *len,
818                        ty: self.lookup_ty(t),
819                    });
820                metadata::Type::FixedLengthList(index)
821            }
822            TypeDefKind::Future(t) => {
823                let index = self.metadata.futures.len();
824
825                let Some(&PayloadData {
826                    new_elem_index,
827                    read_elem_index,
828                    write_elem_index,
829                    cancel_read_elem_index,
830                    cancel_write_elem_index,
831                    drop_readable_elem_index,
832                    drop_writable_elem_index,
833                    ordinal,
834                    ref function,
835                }) = payload_data.get(&id)
836                else {
837                    // Such a type can't be used with `wit-component` currently.
838                    panic!("encountered future type not used in any function")
839                };
840
841                // Compile lift and lower functions for lifting and lowering
842                // items of this future's payload type, if applicable.
843
844                let lift_elem_index = t.map(|t| {
845                    let ty = self.define_ty([ValType::I32; 2], []);
846                    let func = bindgen::lift_payload(self, resolve, t);
847                    let func = self.define_func(
848                        &format!("[future-lift-{ordinal}]{function}"),
849                        ty,
850                        func,
851                        false,
852                    );
853                    self.push_elem(func)
854                });
855
856                let lower_elem_index = t.map(|t| {
857                    let ty = self.define_ty([ValType::I32; 2], []);
858                    let func = bindgen::lower_payload(self, resolve, t);
859                    let func = self.define_func(
860                        &format!("[future-lower-{ordinal}]{function}"),
861                        ty,
862                        func,
863                        false,
864                    );
865                    self.push_elem(func)
866                });
867
868                self.metadata.futures.push(metadata::Future {
869                    id,
870                    interface,
871                    name,
872                    ty: t.map(|t| self.lookup_ty(&t)),
873                    new_elem_index,
874                    read_elem_index,
875                    write_elem_index,
876                    cancel_read_elem_index,
877                    cancel_write_elem_index,
878                    drop_readable_elem_index,
879                    drop_writable_elem_index,
880                    lift_elem_index,
881                    lower_elem_index,
882                    abi_payload_size: t.map(|t| self.sizes.size(&t).size_wasm32()).unwrap_or(0),
883                    abi_payload_align: t.map(|t| self.sizes.align(&t).align_wasm32()).unwrap_or(1),
884                });
885                metadata::Type::Future(index)
886            }
887            TypeDefKind::Stream(t) => {
888                let index = self.metadata.streams.len();
889
890                let Some(&PayloadData {
891                    new_elem_index,
892                    read_elem_index,
893                    write_elem_index,
894                    cancel_read_elem_index,
895                    cancel_write_elem_index,
896                    drop_readable_elem_index,
897                    drop_writable_elem_index,
898                    ordinal,
899                    ref function,
900                }) = payload_data.get(&id)
901                else {
902                    // Such a type can't be used with `wit-component` currently.
903                    panic!("encountered stream type not used in any function")
904                };
905
906                // Compile lift and lower functions for lifting and lowering
907                // items of this stream's payload type, if applicable.
908                //
909                // Note that these functions operate on only a single item,
910                // meaning they must be called in a loop when reading or writing
911                // multiple items.  That saves us from having to generate a Wasm
912                // loop, and allows us to reuse the same code generators for
913                // `future`s and `stream`s, although the result might not be
914                // quite as efficient.
915
916                let lift_elem_index = t.map(|t| {
917                    let ty = self.define_ty([ValType::I32; 2], []);
918                    let func = bindgen::lift_payload(self, resolve, t);
919                    let func = self.define_func(
920                        &format!("[stream-lift-{ordinal}]{function}"),
921                        ty,
922                        func,
923                        false,
924                    );
925                    self.push_elem(func)
926                });
927
928                let lower_elem_index = t.map(|t| {
929                    let ty = self.define_ty([ValType::I32; 2], []);
930                    let func = bindgen::lower_payload(self, resolve, t);
931                    let func = self.define_func(
932                        &format!("[stream-lower-{ordinal}]{function}"),
933                        ty,
934                        func,
935                        false,
936                    );
937                    self.push_elem(func)
938                });
939
940                self.metadata.streams.push(metadata::Stream {
941                    id,
942                    interface,
943                    name,
944                    ty: t.map(|t| self.lookup_ty(&t)),
945                    new_elem_index,
946                    read_elem_index,
947                    write_elem_index,
948                    cancel_read_elem_index,
949                    cancel_write_elem_index,
950                    drop_readable_elem_index,
951                    drop_writable_elem_index,
952                    lift_elem_index,
953                    lower_elem_index,
954                    abi_payload_size: t.map(|t| self.sizes.size(&t).size_wasm32()).unwrap_or(0),
955                    abi_payload_align: t.map(|t| self.sizes.align(&t).align_wasm32()).unwrap_or(1),
956                });
957                metadata::Type::Stream(index)
958            }
959            TypeDefKind::Type(t) => {
960                let index = self.metadata.aliases.len();
961                self.metadata.aliases.push(metadata::Alias {
962                    id,
963                    interface,
964                    name: name.unwrap(),
965                    ty: self.lookup_ty(t),
966                });
967                metadata::Type::Alias(index)
968            }
969            TypeDefKind::Resource => metadata::Type::Own(self.resource_map[&id]),
970
971            // Own/Borrow handles should have already inserted the resource into
972            // `self.resource_map` so this is just a simple lookup.
973            TypeDefKind::Handle(Handle::Own(t)) => {
974                metadata::Type::Own(self.resource_map[&dealias(resolve, *t)])
975            }
976            TypeDefKind::Handle(Handle::Borrow(t)) => {
977                metadata::Type::Borrow(self.resource_map[&dealias(resolve, *t)])
978            }
979            TypeDefKind::Map(k, v) => {
980                let index = self.metadata.maps.len();
981                self.metadata.maps.push(metadata::Map {
982                    id,
983                    interface,
984                    name,
985                    key_type: self.lookup_ty(k),
986                    value_type: self.lookup_ty(v),
987                });
988                metadata::Type::Map(index)
989            }
990            TypeDefKind::Unknown => unreachable!(),
991        };
992        self.type_map.insert(id, result);
993    }
994
995    fn lookup_ty(&self, ty: &Type) -> metadata::Type {
996        match ty {
997            Type::U8 => metadata::Type::U8,
998            Type::U16 => metadata::Type::U16,
999            Type::U32 => metadata::Type::U32,
1000            Type::U64 => metadata::Type::U64,
1001            Type::S8 => metadata::Type::S8,
1002            Type::S16 => metadata::Type::S16,
1003            Type::S32 => metadata::Type::S32,
1004            Type::S64 => metadata::Type::S64,
1005            Type::F32 => metadata::Type::F32,
1006            Type::F64 => metadata::Type::F64,
1007            Type::Bool => metadata::Type::Bool,
1008            Type::Char => metadata::Type::Char,
1009            Type::String => metadata::Type::String,
1010            Type::ErrorContext => metadata::Type::ErrorContext,
1011            // All id-based types should already be registered via
1012            // `register_type` so the hard work is already done and this is a
1013            // simple lookup.
1014            Type::Id(id) => self.type_map[id],
1015        }
1016    }
1017
1018    fn bindgen_world_func_import(&mut self, resolve: &Resolve, import: &WitImport<'_>) {
1019        let func = import.func;
1020        let mangling = self.mangling(resolve, import.interface, func, true);
1021        let body = bindgen::import(
1022            self,
1023            resolve,
1024            func,
1025            mangling.import_variant(),
1026            import.import_index,
1027        );
1028
1029        let ty = if mangling.is_async() {
1030            // [ cx abi_area_ptr ] -> [ status ]
1031            self.define_ty([ValType::I32; 2], [ValType::I32])
1032        } else {
1033            // [ cx ] -> []
1034            self.define_ty([ValType::I32], [])
1035        };
1036
1037        let idx = self.define_func(&format!("adapter {}", func.name), ty, body, false);
1038        let elem_index = self.push_elem(idx);
1039
1040        let sync_import_elem_index;
1041        let async_import_elem_index;
1042        let async_import_lift_results_elem_index;
1043
1044        if mangling.is_async() {
1045            sync_import_elem_index = None;
1046            async_import_elem_index = Some(elem_index);
1047            let body =
1048                bindgen::lift_async_import_results(self, resolve, func, mangling.import_variant());
1049            let ty = self.define_ty([ValType::I32; 2], []);
1050            let idx = self.define_func(&format!("lift results {}", func.name), ty, body, false);
1051            async_import_lift_results_elem_index = Some(self.push_elem(idx));
1052        } else {
1053            sync_import_elem_index = Some(elem_index);
1054            async_import_elem_index = None;
1055            async_import_lift_results_elem_index = None;
1056        }
1057
1058        self.metadata.import_funcs.push(metadata::ImportFunc {
1059            interface: import.interface.map(|k| resolve.name_world_key(k)),
1060            name: func.name.clone(),
1061            sync_import_elem_index,
1062            async_import_elem_index,
1063            async_import_lift_results_elem_index,
1064            args: func.params.iter().map(|p| self.lookup_ty(&p.ty)).collect(),
1065            result: func.result.map(|t| self.lookup_ty(&t)),
1066            async_abi_area: self.async_import_abi_area(resolve, mangling, func),
1067        })
1068    }
1069
1070    /// Returns the `(size, align)` for the indirect params/results as necessary
1071    /// for `func` if `func` is an async function.
1072    fn async_import_abi_area(
1073        &self,
1074        resolve: &Resolve,
1075        mangling: ManglingAndAbi,
1076        func: &wit_parser::Function,
1077    ) -> Option<(usize, usize)> {
1078        if !mangling.is_async() {
1079            return None;
1080        }
1081
1082        let info = self
1083            .sizes
1084            .record(bindgen::async_import_abi_area_types(resolve, func));
1085        Some((info.size.size_wasm32(), info.align.align_wasm32()))
1086    }
1087
1088    fn bindgen_world_func_export(&mut self, resolve: &Resolve, export: &WitExport<'_>) {
1089        let func = export.func;
1090        let mangling = self.mangling(resolve, export.interface, func, false);
1091        let sig = resolve.wasm_signature(mangling.export_variant(), func);
1092        let ty = self.define_wasm_sig(sig);
1093        let name = resolve.wasm_export_name(
1094            mangling,
1095            WasmExport::Func {
1096                interface: export.interface,
1097                func,
1098                kind: WasmExportKind::Normal,
1099            },
1100        );
1101
1102        let metadata_func_index = self.metadata.export_funcs.len();
1103        let body = bindgen::export(
1104            self,
1105            resolve,
1106            func,
1107            mangling.export_variant(),
1108            metadata_func_index,
1109        );
1110        self.define_func(&name, ty, body, true);
1111
1112        let mut async_export_task_return_elem_index = None;
1113        match mangling {
1114            // For sync functions a post-return function is generated which
1115            // cleans up the `cx` argument notably but also any list allocations
1116            // and such as required.
1117            ManglingAndAbi::Standard32 | ManglingAndAbi::Legacy(LiftLowerAbi::Sync) => {
1118                let post_return_name = resolve.wasm_export_name(
1119                    mangling,
1120                    WasmExport::Func {
1121                        interface: export.interface,
1122                        func,
1123                        kind: WasmExportKind::PostReturn,
1124                    },
1125                );
1126                let post_return = bindgen::post_return(
1127                    self,
1128                    resolve,
1129                    func,
1130                    mangling.export_variant(),
1131                    metadata_func_index,
1132                );
1133                let mut sig = resolve.wasm_signature(mangling.export_variant(), func);
1134                sig.params = mem::take(&mut sig.results);
1135                let post_return_ty = self.define_wasm_sig(sig);
1136                self.define_func(&post_return_name, post_return_ty, post_return, true);
1137            }
1138
1139            // For async exports in addition to the main entrypoint a
1140            // `[callback]` function is generated which is invoked when progress
1141            // is made on this function.
1142            //
1143            // Additionally a `task.return` function is generated to be invoked
1144            // once the async export has completed.
1145            ManglingAndAbi::Legacy(LiftLowerAbi::AsyncCallback) => {
1146                let callback_name = resolve.wasm_export_name(
1147                    mangling,
1148                    WasmExport::Func {
1149                        interface: export.interface,
1150                        func,
1151                        kind: WasmExportKind::Callback,
1152                    },
1153                );
1154                // The `[callback]` function is pretty simple, just delegate to
1155                // the `wit_dylib_*` implementation with one extra contextual
1156                // argument. It's the responsibility of the implementation to
1157                // call `context.{get,set}` as appropriate.
1158                let mut callback = Function::new([]);
1159                let mut ins = callback.instructions();
1160                ins.local_get(0);
1161                ins.local_get(1);
1162                ins.local_get(2);
1163                ins.i32_const(metadata_func_index.try_into().unwrap());
1164                let export_async_callback = self.intrinsics().export_async_callback;
1165                ins.call(export_async_callback);
1166                ins.end();
1167                let callback_ty = self.define_ty([ValType::I32; 3], [ValType::I32]);
1168                self.define_func(&callback_name, callback_ty, callback, true);
1169
1170                let task_return = bindgen::task_return(
1171                    self,
1172                    resolve,
1173                    func,
1174                    mangling.export_variant(),
1175                    export.async_task_return_index.unwrap(),
1176                );
1177                let task_return_ty = self.define_ty([ValType::I32], []);
1178                let task_return = self.define_func(
1179                    &format!("task.return {}", func.name),
1180                    task_return_ty,
1181                    task_return,
1182                    false,
1183                );
1184                async_export_task_return_elem_index = Some(self.push_elem(task_return));
1185            }
1186
1187            ManglingAndAbi::Legacy(LiftLowerAbi::AsyncStackful) => unimplemented!(),
1188        }
1189
1190        self.metadata.export_funcs.push(metadata::ExportFunc {
1191            interface: export.interface.map(|k| resolve.name_world_key(k)),
1192            name: func.name.clone(),
1193            async_export_task_return_elem_index,
1194            args: func.params.iter().map(|p| self.lookup_ty(&p.ty)).collect(),
1195            result: func.result.map(|t| self.lookup_ty(&t)),
1196        })
1197    }
1198
1199    fn bindgen_world_export_resource_dtor(
1200        &mut self,
1201        resolve: &Resolve,
1202        interface: &WorldKey,
1203        resource: TypeId,
1204        index: usize,
1205    ) {
1206        let mangling = self.resource_intrinsic_mangling();
1207        let name = resolve.wasm_export_name(
1208            mangling,
1209            WasmExport::ResourceDtor {
1210                interface,
1211                resource,
1212            },
1213        );
1214        let dtor = self.intrinsics().resource_dtor;
1215        let mut func = Function::new([]);
1216        let mut ins = func.instructions();
1217        ins.i32_const(index.try_into().unwrap());
1218        ins.local_get(0);
1219        ins.call(dtor);
1220        ins.end();
1221        let ty = self.define_ty([ValType::I32], []);
1222        self.define_func(&name, ty, func, true);
1223    }
1224
1225    fn encode_metadata(&mut self) -> (u32, Vec<u8>) {
1226        let (metadata_offset, metadata, apply_relocs) =
1227            self.metadata.encode(self.table_base(), self.memory_base());
1228        if let Some(apply_relocs) = apply_relocs {
1229            let ty = self.define_ty([], []);
1230            self.define_func("__wasm_apply_data_relocs", ty, apply_relocs, true);
1231        }
1232        (metadata_offset, metadata)
1233    }
1234
1235    fn table_base(&self) -> u32 {
1236        self.table_base.unwrap()
1237    }
1238
1239    fn intrinsics(&self) -> &bindgen::WitInterpreterIntrinsics {
1240        self.intrinsics.as_ref().unwrap()
1241    }
1242
1243    fn memory_base(&self) -> u32 {
1244        self.memory_base.unwrap()
1245    }
1246
1247    fn push_elem(&mut self, elem: u32) -> u32 {
1248        let ret = self.elem_segment.len();
1249        self.elem_segment.push(elem);
1250        u32::try_from(ret).unwrap()
1251    }
1252
1253    fn finish(&mut self, metadata: &[u8]) -> Vec<u8> {
1254        // Create the element segment dynamically added to the table, if necessary.
1255        let mut elements = ElementSection::new();
1256        if !self.elem_segment.is_empty() {
1257            elements.active(
1258                Some(0),
1259                &ConstExpr::global_get(self.table_base()),
1260                Elements::Functions(Cow::Borrowed(&self.elem_segment)),
1261            );
1262        }
1263
1264        // Add a data segment for the interpreter metadata encoded data in-memory.
1265        let mut data = DataSection::new();
1266        data.active(
1267            0,
1268            &ConstExpr::global_get(self.memory_base()),
1269            metadata.iter().copied(),
1270        );
1271
1272        let mut names = NameSection::new();
1273        names.functions(&self.function_names);
1274        names.globals(&self.global_names);
1275
1276        let dylink0 = {
1277            struct MemInfo {
1278                memory_size: u32,
1279                memory_alignment: u32,
1280                table_size: u32,
1281                table_alignment: u32,
1282            }
1283
1284            let mem_info = MemInfo {
1285                memory_size: metadata.len().try_into().unwrap(),
1286                memory_alignment: 2,
1287                table_size: self.elem_segment.len().try_into().unwrap(),
1288                table_alignment: 0,
1289            };
1290
1291            let mut mem_info_subsection = Vec::new();
1292            mem_info.memory_size.encode(&mut mem_info_subsection);
1293            mem_info.memory_alignment.encode(&mut mem_info_subsection);
1294            mem_info.table_size.encode(&mut mem_info_subsection);
1295            mem_info.table_alignment.encode(&mut mem_info_subsection);
1296
1297            let mut needed_subsection = Vec::new();
1298            if let Some(name) = &self.opts.interpreter {
1299                [name.as_str()].encode(&mut needed_subsection);
1300            }
1301
1302            const WASM_DYLINK_MEM_INFO: u8 = 1;
1303            const WASM_DYLINK_NEEDED: u8 = 2;
1304
1305            let mut dylink0 = Vec::new();
1306            dylink0.push(WASM_DYLINK_MEM_INFO);
1307            mem_info_subsection.encode(&mut dylink0);
1308            if self.opts.interpreter.is_some() {
1309                dylink0.push(WASM_DYLINK_NEEDED);
1310                needed_subsection.encode(&mut dylink0);
1311            }
1312            dylink0
1313        };
1314
1315        let mut result = Module::new();
1316        result.section(&CustomSection {
1317            name: Cow::Borrowed("dylink.0"),
1318            data: Cow::Borrowed(&dylink0),
1319        });
1320        result.section(&self.types);
1321        result.section(&self.imports);
1322        result.section(&self.functions);
1323        result.section(&self.exports);
1324        if !elements.is_empty() {
1325            result.section(&elements);
1326        }
1327        result.section(&self.code);
1328        result.section(&data);
1329        result.section(&names);
1330
1331        result.finish()
1332    }
1333
1334    fn define_wasm_sig(&mut self, sig: WasmSignature) -> u32 {
1335        let ret = self.define_ty(
1336            sig.params
1337                .iter()
1338                .map(|t| self.map_wasm_type(*t))
1339                .collect::<Vec<_>>(),
1340            sig.results
1341                .iter()
1342                .map(|t| self.map_wasm_type(*t))
1343                .collect::<Vec<_>>(),
1344        );
1345        return ret;
1346    }
1347
1348    fn map_wasm_type(&self, a: WasmType) -> ValType {
1349        match a {
1350            WasmType::I32 => ValType::I32,
1351            WasmType::I64 => ValType::I64,
1352            WasmType::F32 => ValType::F32,
1353            WasmType::F64 => ValType::F64,
1354            WasmType::PointerOrI64 => ValType::I64,
1355            WasmType::Length | WasmType::Pointer => ValType::I32,
1356        }
1357    }
1358
1359    fn import_global(&mut self, module: &str, name: &str, ty: GlobalType) -> u32 {
1360        assert!(!self.imports_done);
1361        self.imports.import(module, name, ty);
1362        let ret = self.global_index;
1363        self.global_index += 1;
1364        self.global_names.append(ret, name);
1365        ret
1366    }
1367
1368    fn import_func(&mut self, module: &str, name: &str, ty: u32) -> u32 {
1369        assert!(!self.imports_done);
1370        self.imports.import(module, name, EntityType::Function(ty));
1371        let ret = self.func_index;
1372        self.func_index += 1;
1373        self.function_names.append(ret, name);
1374        ret
1375    }
1376
1377    fn define_func(&mut self, name: &str, ty: u32, body: Function, export: bool) -> u32 {
1378        assert!(self.imports_done);
1379        let ret = self.func_index;
1380        self.func_index += 1;
1381        self.functions.function(ty);
1382        self.code.function(&body);
1383        self.function_names.append(ret, name);
1384        if export {
1385            self.exports.export(name, ExportKind::Func, ret);
1386        }
1387        ret
1388    }
1389
1390    fn define_ty<P, R>(&mut self, params: P, results: R) -> u32
1391    where
1392        P: IntoIterator<Item = ValType> + Clone,
1393        P::IntoIter: ExactSizeIterator,
1394        R: IntoIterator<Item = ValType> + Clone,
1395        R::IntoIter: ExactSizeIterator,
1396    {
1397        let param_vec = params.clone().into_iter().collect::<Vec<_>>();
1398        let result_vec = results.clone().into_iter().collect::<Vec<_>>();
1399        *self
1400            .wasm_type_map
1401            .entry((param_vec, result_vec))
1402            .or_insert_with(|| {
1403                let ret = self.types.len();
1404                self.types.ty().function(params, results);
1405                ret
1406            })
1407    }
1408}
1409
1410fn imported_types_used_by_exported_interfaces(resolve: &Resolve, world: WorldId) -> LiveTypes {
1411    // First build up a set of all types used by exported interfaces which
1412    // define their own types.
1413    let mut live_export_types = LiveTypes::default();
1414    let mut exported_interfaces = HashSet::new();
1415    for (_, export) in resolve.worlds[world].exports.iter() {
1416        match export {
1417            WorldItem::Function(_) => {}
1418            WorldItem::Interface { id, .. } => {
1419                exported_interfaces.insert(*id);
1420                live_export_types.add_interface(resolve, *id)
1421            }
1422            WorldItem::Type { .. } => unreachable!(),
1423        }
1424    }
1425
1426    // Using the above sets a new set is built of all types that aren't
1427    // reexported. All types used by exports, which are defined by an interface
1428    // that is NOT an export, is an imported type used by an export.
1429    let mut live_import_types = LiveTypes::default();
1430    for ty in live_export_types.iter() {
1431        if let TypeOwner::Interface(id) = resolve.types[ty].owner {
1432            if !exported_interfaces.contains(&id) {
1433                live_import_types.add_interface(resolve, id);
1434            }
1435        }
1436    }
1437
1438    live_import_types
1439}
1440
1441fn dealias(resolve: &Resolve, mut id: TypeId) -> TypeId {
1442    loop {
1443        match resolve.types[id].kind {
1444            TypeDefKind::Type(Type::Id(other)) => id = other,
1445            _ => break id,
1446        }
1447    }
1448}
1449
1450#[cfg(test)]
1451mod tests {
1452    use wasmparser::{Operator, Parser, Payload};
1453    use wit_parser::Resolve;
1454
1455    #[derive(Copy, Clone)]
1456    enum Which {
1457        S8,
1458        S16,
1459    }
1460
1461    #[test]
1462    fn s8_uses_signed_load() {
1463        assert!(find_signed_load(Which::S8));
1464    }
1465
1466    #[test]
1467    fn s16_uses_signed_load() {
1468        assert!(find_signed_load(Which::S16));
1469    }
1470
1471    fn find_signed_load(which: Which) -> bool {
1472        let mut resolve = Resolve::default();
1473        let ty = match which {
1474            Which::S8 => "s8",
1475            Which::S16 => "s16",
1476        };
1477        let package = resolve
1478            .push_str(
1479                "wit",
1480                &format!(
1481                    "package test:test;
1482world w {{
1483  export foo: func(v: list<{ty}>);
1484}}
1485"
1486                ),
1487            )
1488            .unwrap();
1489        let world = resolve.select_world(&[package], None).unwrap();
1490        let adapter = super::create(&resolve, world, None);
1491        for payload in Parser::new(0).parse_all(&adapter) {
1492            match payload.unwrap() {
1493                Payload::CodeSectionEntry(body) => {
1494                    for operator in body.get_operators_reader().unwrap() {
1495                        match (operator.unwrap(), which) {
1496                            (Operator::I32Load16S { .. }, Which::S16)
1497                            | (Operator::I32Load8S { .. }, Which::S8) => return true,
1498                            _ => {}
1499                        }
1500                    }
1501                }
1502                _ => {}
1503            }
1504        }
1505        false
1506    }
1507}