Function convert_module_import

crates/parser/src/conversion.rs:58–86

(import: wasmparser::Import<'_>)

}

pub(crate) fn convert_module_import(import: wasmparser::Import<'_>) -> Result<Import> {
    let kind = match import.ty {
        wasmparser::TypeRef::Func(ty) => ImportKind::Function(ty),
        wasmparser::TypeRef::Table(ty) => ImportKind::Table(TableType {
            element_type: convert_reftype(ty.element_type)?,
            size_initial: ty.initial.try_into().map_err(|_| {
                crate::ParseError::UnsupportedOperator(format!("Table size initial is too large: {}", ty.initial))
            })?,
            size_max: match ty.maximum {
                Some(max) => Some(max.try_into().map_err(|_| {
                    crate::ParseError::UnsupportedOperator(format!("Table size max is too large: {max}"))
                })?),
                None => None,
            },
        }),
        wasmparser::TypeRef::Memory(ty) => ImportKind::Memory(convert_module_memory(ty)),
        wasmparser::TypeRef::Global(ty) => {
            ImportKind::Global(GlobalType::new(convert_valtype(&ty.content_type)?, ty.mutable))
        }
        wasmparser::TypeRef::Tag(ty) => {
            return Err(crate::ParseError::UnsupportedOperator(format!("Unsupported import kind: {ty:?}")));
        }
        _ => {
            return Err(crate::ParseError::UnsupportedOperator(format!("Unsupported import kind: {:?}", import.ty)));
        }
    };

    Ok(Import { module: import.module.into(), name: import.name.into(), kind })
}

pub(crate) fn convert_module_memory(memory: wasmparser::MemoryType) -> MemoryType {
    MemoryType::new(