Method link

crates/tinywasm/src/imports.rs:214–329

(&self, store: &mut crate::Store, module: &Module)

    }

    pub(crate) fn link(&self, store: &mut crate::Store, module: &Module) -> Result<ResolvedImports> {
        let (global_count, table_count, mem_count, func_count) =
            module.imports.iter().fold((0, 0, 0, 0), |(g, t, m, f), import| match import.kind {
                ImportKind::Global(_) => (g + 1, t, m, f),
                ImportKind::Table(_) => (g, t + 1, m, f),
                ImportKind::Memory(_) => (g, t, m + 1, f),
                ImportKind::Function(_) => (g, t, m, f + 1),
            });

        let mut imports = ResolvedImports {
            globals: Vec::with_capacity(global_count + module.globals.len()),
            tables: Vec::with_capacity(table_count + module.table_types.len()),
            memories: Vec::with_capacity(mem_count + module.memory_types.len()),
            funcs: Vec::with_capacity(func_count + module.funcs.len()),
        };

        for import in &*module.imports {
            if let Some(defined) = self.take_defined(import) {
                match defined {
                    Extern::Global(global) => {
                        let ImportKind::Global(import_ty) = &import.kind else {
                            cold_path();
                            return Err(LinkingError::incompatible_import_type(import).into());
                        };
                        let global_instance = store.state.get_global(global.0.addr);
                        Self::compare_types(import, &global_instance.ty, import_ty)?;
                        imports.globals.push(global.0.addr);
                    }
                    Extern::Table(table) => {
                        let ImportKind::Table(import_ty) = &import.kind else {
                            cold_path();
                            return Err(LinkingError::incompatible_import_type(import).into());
                        };
                        let table_instance = store.state.get_table(table.0.addr);
                        let mut kind = table_instance.kind.clone();
                        kind.size_initial = table_instance.size() as u32;
                        Self::compare_table_types(import, &kind, import_ty)?;
                        imports.tables.push(table.0.addr);
                    }
                    Extern::Memory(memory) => {
                        let ImportKind::Memory(import_ty) = &import.kind else {
                            cold_path();
                            return Err(LinkingError::incompatible_import_type(import).into());
                        };
                        let mem = store.state.get_mem(memory.0.addr);
                        Self::compare_memory_types(import, &mem.kind, import_ty, mem.page_count)?;
                        imports.memories.push(memory.0.addr);
                    }
                    Extern::Function(func_handle) => {
                        let ImportKind::Function(ty) = &import.kind else {
                            cold_path();
                            return Err(LinkingError::incompatible_import_type(import).into());
                        };
                        let import_func_type = module
                            .func_types
                            .get(*ty as usize)
                            .ok_or_else(|| LinkingError::incompatible_import_type(import))?;
                        func_handle.item.validate_store(store)?;