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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use super::{COMPONENT_SORT, CORE_MODULE_SORT, CORE_SORT, CORE_TYPE_SORT, TYPE_SORT};
use crate::{
    encode_section, ComponentExportKind, ComponentSection, ComponentSectionId, Encode, ExportKind,
};

/// Represents the kinds of outer aliasable items in a component.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ComponentOuterAliasKind {
    /// The alias is to a core module.
    CoreModule,
    /// The alias is to a core type.
    CoreType,
    /// The alias is to a type.
    Type,
    /// The alias is to a component.
    Component,
}

impl Encode for ComponentOuterAliasKind {
    fn encode(&self, sink: &mut Vec<u8>) {
        match self {
            Self::CoreModule => {
                sink.push(CORE_SORT);
                sink.push(CORE_MODULE_SORT);
            }
            Self::CoreType => {
                sink.push(CORE_SORT);
                sink.push(CORE_TYPE_SORT);
            }
            Self::Type => sink.push(TYPE_SORT),
            Self::Component => sink.push(COMPONENT_SORT),
        }
    }
}

/// An encoder for the alias section of WebAssembly component.
///
/// # Example
///
/// ```rust
/// use wasm_encoder::{Component, Alias, ComponentAliasSection, ComponentExportKind, ComponentOuterAliasKind};
///
/// let mut aliases = ComponentAliasSection::new();
/// aliases.alias(Alias::InstanceExport { instance: 0, kind: ComponentExportKind::Func, name: "f" });
/// aliases.alias(Alias::Outer { count: 0, kind: ComponentOuterAliasKind::Type, index: 1 });
///
/// let mut component = Component::new();
/// component.section(&aliases);
///
/// let bytes = component.finish();
/// ```
#[derive(Clone, Debug, Default)]
pub struct ComponentAliasSection {
    bytes: Vec<u8>,
    num_added: u32,
}

/// Different forms of aliases that can be inserted into a
/// [`ComponentAliasSection`].
#[derive(Copy, Clone, Debug)]
pub enum Alias<'a> {
    /// An alias of a component instance export.
    InstanceExport {
        /// The index of the component instance that's being aliased from.
        instance: u32,
        /// The kind of item that's being extracted from the component
        /// instance.
        kind: ComponentExportKind,
        /// The name of the export that's being aliased.
        name: &'a str,
    },
    /// Same as `InstanceExport`, but for core instances.
    #[allow(missing_docs)]
    CoreInstanceExport {
        instance: u32,
        kind: ExportKind,
        name: &'a str,
    },
    /// Aliasing an item from an outer component.
    Outer {
        /// The kind of item being aliased, either a type or a component.
        kind: ComponentOuterAliasKind,
        /// Number of levels "up" to go to lookup the index within. Level 0 is
        /// the current scope and level 1 is the enclosing scope, and so on.
        count: u32,
        /// The index of the item to alias within the scope referenced by
        /// `count`.
        index: u32,
    },
}

impl ComponentAliasSection {
    /// Create a new alias section encoder.
    pub fn new() -> Self {
        Self::default()
    }

    /// The number of aliases in the section.
    pub fn len(&self) -> u32 {
        self.num_added
    }

    /// Determines if the section is empty.
    pub fn is_empty(&self) -> bool {
        self.num_added == 0
    }

    /// Define an alias to a component instance's export.
    pub fn alias(&mut self, alias: Alias<'_>) -> &mut Self {
        alias.encode(&mut self.bytes);
        self.num_added += 1;
        self
    }
}

impl Encode for ComponentAliasSection {
    fn encode(&self, sink: &mut Vec<u8>) {
        encode_section(sink, self.num_added, &self.bytes);
    }
}

impl ComponentSection for ComponentAliasSection {
    fn id(&self) -> u8 {
        ComponentSectionId::Alias.into()
    }
}

impl Encode for Alias<'_> {
    fn encode(&self, sink: &mut Vec<u8>) {
        match self {
            Alias::InstanceExport {
                instance,
                kind,
                name,
            } => {
                kind.encode(sink);
                sink.push(0x00);
                instance.encode(sink);
                name.encode(sink);
            }
            Alias::CoreInstanceExport {
                instance,
                kind,
                name,
            } => {
                sink.push(CORE_SORT);
                kind.encode(sink);
                sink.push(0x01);
                instance.encode(sink);
                name.encode(sink);
            }
            Alias::Outer { kind, count, index } => {
                kind.encode(sink);
                sink.push(0x02);
                count.encode(sink);
                index.encode(sink);
            }
        }
    }
}