/build/cargo-vendor-dir/wasm-encoder-0.212.0/src/component/aliases.rs

Source (jump to first uncovered line)
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);
            }
        }
    }
}

Line	Count	Source (jump to first uncovered line)
1		use super::{COMPONENT_SORT, CORE_MODULE_SORT, CORE_SORT, CORE_TYPE_SORT, TYPE_SORT};
2		use crate::{
3		encode_section, ComponentExportKind, ComponentSection, ComponentSectionId, Encode, ExportKind,
4		};
5
6		/// Represents the kinds of outer aliasable items in a component.
7		#[derive(Clone, Copy, Debug, Eq, PartialEq)]
8		pub enum ComponentOuterAliasKind {
9		/// The alias is to a core module.
10		CoreModule,
11		/// The alias is to a core type.
12		CoreType,
13		/// The alias is to a type.
14		Type,
15		/// The alias is to a component.
16		Component,
17		}
18
19		impl Encode for ComponentOuterAliasKind {
20	0	fn encode(&self, sink: &mut Vec<u8>) {
21	0	match self {
22	0	Self::CoreModule => {
23	0	sink.push(CORE_SORT);
24	0	sink.push(CORE_MODULE_SORT);
25	0	}
26	0	Self::CoreType => {
27	0	sink.push(CORE_SORT);
28	0	sink.push(CORE_TYPE_SORT);
29	0	}
30	0	Self::Type => sink.push(TYPE_SORT),
31	0	Self::Component => sink.push(COMPONENT_SORT),
32		}
33	0	}
34		}
35
36		/// An encoder for the alias section of WebAssembly component.
37		///
38		/// # Example
39		///
40		/// ```rust
41		/// use wasm_encoder::{Component, Alias, ComponentAliasSection, ComponentExportKind, ComponentOuterAliasKind};
42		///
43		/// let mut aliases = ComponentAliasSection::new();
44		/// aliases.alias(Alias::InstanceExport { instance: 0, kind: ComponentExportKind::Func, name: "f" });
45		/// aliases.alias(Alias::Outer { count: 0, kind: ComponentOuterAliasKind::Type, index: 1 });
46		///
47		/// let mut component = Component::new();
48		/// component.section(&aliases);
49		///
50		/// let bytes = component.finish();
51		/// ```
52		#[derive(Clone, Debug, Default)]
53		pub struct ComponentAliasSection {
54		bytes: Vec<u8>,
55		num_added: u32,
56		}
57
58		/// Different forms of aliases that can be inserted into a
59		/// [`ComponentAliasSection`].
60		#[derive(Copy, Clone, Debug)]
61		pub enum Alias<'a> {
62		/// An alias of a component instance export.
63		InstanceExport {
64		/// The index of the component instance that's being aliased from.
65		instance: u32,
66		/// The kind of item that's being extracted from the component
67		/// instance.
68		kind: ComponentExportKind,
69		/// The name of the export that's being aliased.
70		name: &'a str,
71		},
72		/// Same as `InstanceExport`, but for core instances.
73		#[allow(missing_docs)]
74		CoreInstanceExport {
75		instance: u32,
76		kind: ExportKind,
77		name: &'a str,
78		},
79		/// Aliasing an item from an outer component.
80		Outer {
81		/// The kind of item being aliased, either a type or a component.
82		kind: ComponentOuterAliasKind,
83		/// Number of levels "up" to go to lookup the index within. Level 0 is
84		/// the current scope and level 1 is the enclosing scope, and so on.
85		count: u32,
86		/// The index of the item to alias within the scope referenced by
87		/// `count`.
88		index: u32,
89		},
90		}
91
92		impl ComponentAliasSection {
93		/// Create a new alias section encoder.
94	0	pub fn new() -> Self {
95	0	Self::default()
96	0	}
97
98		/// The number of aliases in the section.
99	0	pub fn len(&self) -> u32 {
100	0	self.num_added
101	0	}
102
103		/// Determines if the section is empty.
104	0	pub fn is_empty(&self) -> bool {
105	0	self.num_added == 0
106	0	}
107
108		/// Define an alias to a component instance's export.
109	0	pub fn alias(&mut self, alias: Alias<'_>) -> &mut Self {
110	0	alias.encode(&mut self.bytes);
111	0	self.num_added += 1;
112	0	self
113	0	}
114		}
115
116		impl Encode for ComponentAliasSection {
117	0	fn encode(&self, sink: &mut Vec<u8>) {
118	0	encode_section(sink, self.num_added, &self.bytes);
119	0	}
120		}
121
122		impl ComponentSection for ComponentAliasSection {
123	0	fn id(&self) -> u8 {
124	0	ComponentSectionId::Alias.into()
125	0	}
126		}
127
128		impl Encode for Alias<'_> {
129	0	fn encode(&self, sink: &mut Vec<u8>) {
130	0	match self {
131		Alias::InstanceExport {
132	0	instance,
133	0	kind,
134	0	name,
135	0	} => {
136	0	kind.encode(sink);
137	0	sink.push(0x00);
138	0	instance.encode(sink);
139	0	name.encode(sink);
140	0	}
141		Alias::CoreInstanceExport {
142	0	instance,
143	0	kind,
144	0	name,
145	0	} => {
146	0	sink.push(CORE_SORT);
147	0	kind.encode(sink);
148	0	sink.push(0x01);
149	0	instance.encode(sink);
150	0	name.encode(sink);
151	0	}
152	0	Alias::Outer { kind, count, index } => {
153	0	kind.encode(sink);
154	0	sink.push(0x02);
155	0	count.encode(sink);
156	0	index.encode(sink);
157	0	}
158		}
159	0	}
160		}

Coverage Report

Created: 2024-11-19 11:03