wasmtime 15.0.1 → 16.0.0

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/producers.rs

@@ -1,180 +0,0 @@
-use std::borrow::Cow;
-
-use crate::{CustomSection, Encode, Section, SectionId};
-
-/// An encoder for the [producers custom
-/// section](https://github.com/WebAssembly/tool-conventions/blob/main/ProducersSection.md).
-///
-/// This section is a non-standard convention that is supported by many toolchains.
-///
-/// # Example
-///
-/// ```
-/// use wasm_encoder::{ProducersSection, ProducersField, Module};
-///
-/// // Create a new producers section.
-/// let mut field = ProducersField::new();
-/// field.value("clang", "14.0.4");
-/// field.value("rustc", "1.66.1 (90743e729 2023-01-10)");
-/// let mut producers = ProducersSection::new();
-/// producers.field("processed-by", &field);
-///
-/// // Add the producers section to a new Wasm module and get the encoded bytes.
-/// let mut module = Module::new();
-/// module.section(&producers);
-/// let wasm_bytes = module.finish();
-/// ```
-#[derive(Clone, Debug)]
-pub struct ProducersSection {
-    bytes: Vec<u8>,
-    num_fields: u32,
-}
-
-impl ProducersSection {
-    /// Construct an empty encoder for the producers custom section.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Add a field to the section. The spec recommends names for this section
-    /// are "language", "processed-by", and "sdk".  Each field in section must
-    /// have a unique name.
-    pub fn field(&mut self, name: &str, values: &ProducersField) -> &mut Self {
-        name.encode(&mut self.bytes);
-        values.encode(&mut self.bytes);
-        self.num_fields += 1;
-        self
-    }
-}
-
-impl Default for ProducersSection {
-    fn default() -> Self {
-        Self {
-            bytes: Vec::new(),
-            num_fields: 0,
-        }
-    }
-}
-
-impl Encode for ProducersSection {
-    fn encode(&self, sink: &mut Vec<u8>) {
-        let mut data = Vec::new();
-        self.num_fields.encode(&mut data);
-        data.extend(&self.bytes);
-
-        CustomSection {
-            name: "producers".into(),
-            data: Cow::Borrowed(&data),
-        }
-        .encode(sink);
-    }
-}
-
-impl Section for ProducersSection {
-    fn id(&self) -> u8 {
-        SectionId::Custom.into()
-    }
-}
-
-/// The value of a field in the producers custom section
-#[derive(Clone, Debug)]
-pub struct ProducersField {
-    bytes: Vec<u8>,
-    num_values: u32,
-}
-
-impl ProducersField {
-    /// Construct an empty encoder for a producers field value
-    pub fn new() -> Self {
-        ProducersField::default()
-    }
-
-    /// Add a value to the field encoder. Each value in a field must have a
-    /// unique name. If there is no sensible value for `version`, use the
-    /// empty string.
-    pub fn value(&mut self, name: &str, version: &str) -> &mut Self {
-        name.encode(&mut self.bytes);
-        version.encode(&mut self.bytes);
-        self.num_values += 1;
-        self
-    }
-}
-
-impl Default for ProducersField {
-    fn default() -> Self {
-        Self {
-            bytes: Vec::new(),
-            num_values: 0,
-        }
-    }
-}
-
-impl Encode for ProducersField {
-    fn encode(&self, sink: &mut Vec<u8>) {
-        self.num_values.encode(sink);
-        sink.extend(&self.bytes);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #[test]
-    fn roundtrip_example() {
-        use crate::{Module, ProducersField, ProducersSection};
-        use wasmparser::{Parser, Payload, ProducersSectionReader};
-
-        // Create a new producers section.
-        let mut field = ProducersField::new();
-        field.value("clang", "14.0.4");
-        field.value("rustc", "1.66.1");
-        let mut producers = ProducersSection::new();
-        producers.field("processed-by", &field);
-
-        // Add the producers section to a new Wasm module and get the encoded bytes.
-        let mut module = Module::new();
-        module.section(&producers);
-        let wasm_bytes = module.finish();
-
-        let mut parser = Parser::new(0).parse_all(&wasm_bytes);
-        let payload = parser
-            .next()
-            .expect("parser is not empty")
-            .expect("element is a payload");
-        match payload {
-            Payload::Version { .. } => {}
-            _ => panic!(""),
-        }
-        let payload = parser
-            .next()
-            .expect("parser is not empty")
-            .expect("element is a payload");
-        match payload {
-            Payload::CustomSection(c) => {
-                assert_eq!(c.name(), "producers");
-                let mut section = ProducersSectionReader::new(c.data(), c.data_offset())
-                    .expect("readable as a producers section")
-                    .into_iter();
-                let field = section
-                    .next()
-                    .expect("section has an element")
-                    .expect("element is a producers field");
-                assert_eq!(field.name, "processed-by");
-                let mut values = field.values.into_iter();
-                let value = values
-                    .next()
-                    .expect("values has an element")
-                    .expect("element is a producers field value");
-                assert_eq!(value.name, "clang");
-                assert_eq!(value.version, "14.0.4");
-
-                let value = values
-                    .next()
-                    .expect("values has another element")
-                    .expect("element is a producers field value");
-                assert_eq!(value.name, "rustc");
-                assert_eq!(value.version, "1.66.1");
-            }
-            _ => panic!("unexpected payload"),
-        }
-    }
-}

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/start.rs

@@ -1,39 +0,0 @@
-use crate::{encoding_size, Encode, Section, SectionId};
-
-/// An encoder for the start section of WebAssembly modules.
-///
-/// # Example
-///
-/// Note: this doesn't actually define the function at index 0, its type, or its
-/// code body, so the resulting Wasm module will be invalid. See `TypeSection`,
-/// `FunctionSection`, and `CodeSection` for details on how to generate those
-/// things.
-///
-/// ```
-/// use wasm_encoder::{Module, StartSection};
-///
-/// let start = StartSection { function_index: 0 };
-///
-/// let mut module = Module::new();
-/// module.section(&start);
-///
-/// let wasm_bytes = module.finish();
-/// ```
-#[derive(Clone, Copy, Debug)]
-pub struct StartSection {
-    /// The index of the start function.
-    pub function_index: u32,
-}
-
-impl Encode for StartSection {
-    fn encode(&self, sink: &mut Vec<u8>) {
-        encoding_size(self.function_index).encode(sink);
-        self.function_index.encode(sink);
-    }
-}
-
-impl Section for StartSection {
-    fn id(&self) -> u8 {
-        SectionId::Start.into()
-    }
-}

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/tables.rs

@@ -1,115 +0,0 @@
-use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
-
-/// An encoder for the table section.
-///
-/// Table sections are only supported for modules.
-///
-/// # Example
-///
-/// ```
-/// use wasm_encoder::{Module, TableSection, TableType, RefType};
-///
-/// let mut tables = TableSection::new();
-/// tables.table(TableType {
-///     element_type: RefType::FUNCREF,
-///     minimum: 128,
-///     maximum: None,
-/// });
-///
-/// let mut module = Module::new();
-/// module.section(&tables);
-///
-/// let wasm_bytes = module.finish();
-/// ```
-#[derive(Clone, Default, Debug)]
-pub struct TableSection {
-    bytes: Vec<u8>,
-    num_added: u32,
-}
-
-impl TableSection {
-    /// Construct a new table section encoder.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// The number of tables 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 a table.
-    pub fn table(&mut self, table_type: TableType) -> &mut Self {
-        table_type.encode(&mut self.bytes);
-        self.num_added += 1;
-        self
-    }
-
-    /// Define a table with an explicit initialization expression.
-    ///
-    /// Note that this is part of the function-references proposal.
-    pub fn table_with_init(&mut self, table_type: TableType, init: &ConstExpr) -> &mut Self {
-        self.bytes.push(0x40);
-        self.bytes.push(0x00);
-        table_type.encode(&mut self.bytes);
-        init.encode(&mut self.bytes);
-        self.num_added += 1;
-        self
-    }
-}
-
-impl Encode for TableSection {
-    fn encode(&self, sink: &mut Vec<u8>) {
-        encode_section(sink, self.num_added, &self.bytes);
-    }
-}
-
-impl Section for TableSection {
-    fn id(&self) -> u8 {
-        SectionId::Table.into()
-    }
-}
-
-/// A table's type.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub struct TableType {
-    /// The table's element type.
-    pub element_type: RefType,
-    /// Minimum size, in elements, of this table
-    pub minimum: u32,
-    /// Maximum size, in elements, of this table
-    pub maximum: Option<u32>,
-}
-
-impl Encode for TableType {
-    fn encode(&self, sink: &mut Vec<u8>) {
-        let mut flags = 0;
-        if self.maximum.is_some() {
-            flags |= 0b001;
-        }
-
-        self.element_type.encode(sink);
-        sink.push(flags);
-        self.minimum.encode(sink);
-
-        if let Some(max) = self.maximum {
-            max.encode(sink);
-        }
-    }
-}
-
-#[cfg(feature = "wasmparser")]
-impl From<wasmparser::TableType> for TableType {
-    fn from(table_ty: wasmparser::TableType) -> Self {
-        TableType {
-            element_type: table_ty.element_type.into(),
-            minimum: table_ty.initial,
-            maximum: table_ty.maximum,
-        }
-    }
-}

data/ext/cargo-vendor/wasm-encoder-0.36.2/src/core/tags.rs

@@ -1,104 +0,0 @@
-use crate::{encode_section, Encode, Section, SectionId};
-
-/// An encoder for the tag section.
-///
-/// # Example
-///
-/// ```
-/// use wasm_encoder::{Module, TagSection, TagType, TagKind};
-///
-/// let mut tags = TagSection::new();
-/// tags.tag(TagType {
-///     kind: TagKind::Exception,
-///     func_type_idx: 0,
-/// });
-///
-/// let mut module = Module::new();
-/// module.section(&tags);
-///
-/// let wasm_bytes = module.finish();
-/// ```
-#[derive(Clone, Default, Debug)]
-pub struct TagSection {
-    bytes: Vec<u8>,
-    num_added: u32,
-}
-
-impl TagSection {
-    /// Create a new tag section encoder.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// The number of tags 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 a tag.
-    pub fn tag(&mut self, tag_type: TagType) -> &mut Self {
-        tag_type.encode(&mut self.bytes);
-        self.num_added += 1;
-        self
-    }
-}
-
-impl Encode for TagSection {
-    fn encode(&self, sink: &mut Vec<u8>) {
-        encode_section(sink, self.num_added, &self.bytes);
-    }
-}
-
-impl Section for TagSection {
-    fn id(&self) -> u8 {
-        SectionId::Tag.into()
-    }
-}
-
-/// Represents a tag kind.
-#[repr(u8)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum TagKind {
-    /// The tag is an exception type.
-    Exception = 0x0,
-}
-
-#[cfg(feature = "wasmparser")]
-impl From<wasmparser::TagKind> for TagKind {
-    fn from(kind: wasmparser::TagKind) -> Self {
-        match kind {
-            wasmparser::TagKind::Exception => TagKind::Exception,
-        }
-    }
-}
-
-/// A tag's type.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct TagType {
-    /// The kind of tag
-    pub kind: TagKind,
-    /// The function type this tag uses
-    pub func_type_idx: u32,
-}
-
-impl Encode for TagType {
-    fn encode(&self, sink: &mut Vec<u8>) {
-        sink.push(self.kind as u8);
-        self.func_type_idx.encode(sink);
-    }
-}
-
-#[cfg(feature = "wasmparser")]
-impl From<wasmparser::TagType> for TagType {
-    fn from(tag_ty: wasmparser::TagType) -> Self {
-        TagType {
-            kind: tag_ty.kind.into(),
-            func_type_idx: tag_ty.func_type_idx,
-        }
-    }
-}