spin_componentize/
convert.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#![allow(clippy::from_over_into)]

use wasm_encoder::{
    AbstractHeapType, EntityType, ExportKind, GlobalType, HeapType, MemoryType, RefType, TableType,
    TagKind, TagType, ValType,
};

struct IntoHeapType(wasmparser::HeapType);

impl Into<HeapType> for IntoHeapType {
    fn into(self) -> HeapType {
        match self.0 {
            wasmparser::HeapType::Concrete(_) => {
                panic!("user-defined heap types not yet supported")
            }
            wasmparser::HeapType::Abstract { ty, shared } => {
                let ty = match ty {
                    wasmparser::AbstractHeapType::Func => AbstractHeapType::Func,
                    wasmparser::AbstractHeapType::Extern => AbstractHeapType::Extern,
                    wasmparser::AbstractHeapType::Any => AbstractHeapType::Any,
                    wasmparser::AbstractHeapType::None => AbstractHeapType::None,
                    wasmparser::AbstractHeapType::NoExtern => AbstractHeapType::NoExtern,
                    wasmparser::AbstractHeapType::NoFunc => AbstractHeapType::NoFunc,
                    wasmparser::AbstractHeapType::Eq => AbstractHeapType::Eq,
                    wasmparser::AbstractHeapType::Struct => AbstractHeapType::Struct,
                    wasmparser::AbstractHeapType::Array => AbstractHeapType::Array,
                    wasmparser::AbstractHeapType::I31 => AbstractHeapType::I31,
                    wasmparser::AbstractHeapType::Exn => AbstractHeapType::Exn,
                    wasmparser::AbstractHeapType::NoExn => AbstractHeapType::NoExn,
                };
                HeapType::Abstract { shared, ty }
            }
        }
    }
}

struct IntoRefType(wasmparser::RefType);

impl Into<RefType> for IntoRefType {
    fn into(self) -> RefType {
        RefType {
            nullable: self.0.is_nullable(),
            heap_type: IntoHeapType(self.0.heap_type()).into(),
        }
    }
}

struct IntoValType(wasmparser::ValType);

impl Into<ValType> for IntoValType {
    fn into(self) -> ValType {
        match self.0 {
            wasmparser::ValType::I32 => ValType::I32,
            wasmparser::ValType::I64 => ValType::I64,
            wasmparser::ValType::F32 => ValType::F32,
            wasmparser::ValType::F64 => ValType::F64,
            wasmparser::ValType::V128 => ValType::V128,
            wasmparser::ValType::Ref(ty) => ValType::Ref(IntoRefType(ty).into()),
        }
    }
}

struct IntoTagKind(wasmparser::TagKind);

impl Into<TagKind> for IntoTagKind {
    fn into(self) -> TagKind {
        match self.0 {
            wasmparser::TagKind::Exception => TagKind::Exception,
        }
    }
}

pub struct IntoEntityType(pub wasmparser::TypeRef);

impl Into<EntityType> for IntoEntityType {
    fn into(self) -> EntityType {
        match self.0 {
            wasmparser::TypeRef::Func(index) => EntityType::Function(index),
            wasmparser::TypeRef::Table(ty) => EntityType::Table(TableType {
                element_type: IntoRefType(ty.element_type).into(),
                minimum: ty.initial,
                maximum: ty.maximum,
                table64: ty.table64,
                shared: ty.shared,
            }),
            wasmparser::TypeRef::Memory(ty) => EntityType::Memory(MemoryType {
                minimum: ty.initial,
                maximum: ty.maximum,
                memory64: ty.memory64,
                shared: ty.shared,
                page_size_log2: ty.page_size_log2,
            }),
            wasmparser::TypeRef::Global(ty) => EntityType::Global(GlobalType {
                val_type: IntoValType(ty.content_type).into(),
                mutable: ty.mutable,
                shared: ty.shared,
            }),
            wasmparser::TypeRef::Tag(ty) => EntityType::Tag(TagType {
                kind: IntoTagKind(ty.kind).into(),
                func_type_idx: ty.func_type_idx,
            }),
        }
    }
}

pub struct IntoExportKind(pub wasmparser::ExternalKind);

impl Into<ExportKind> for IntoExportKind {
    fn into(self) -> ExportKind {
        match self.0 {
            wasmparser::ExternalKind::Func => ExportKind::Func,
            wasmparser::ExternalKind::Table => ExportKind::Table,
            wasmparser::ExternalKind::Memory => ExportKind::Memory,
            wasmparser::ExternalKind::Global => ExportKind::Global,
            wasmparser::ExternalKind::Tag => ExportKind::Tag,
        }
    }
}