wasmtime 24.0.0 → 25.0.0

data/ext/cargo-vendor/wasmparser-0.215.0/src/readers/component/aliases.rs

@@ -1,119 +0,0 @@
-use crate::{BinaryReader, ComponentExternalKind, ExternalKind, FromReader, Result};
-
-/// Represents the kind of an outer alias in a WebAssembly 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 component type.
-    Type,
-    /// The alias is to a component.
-    Component,
-}
-
-/// Represents an alias in a WebAssembly component.
-#[derive(Debug, Clone)]
-pub enum ComponentAlias<'a> {
-    /// The alias is to an export of a component instance.
-    InstanceExport {
-        /// The alias kind.
-        kind: ComponentExternalKind,
-        /// The instance index.
-        instance_index: u32,
-        /// The export name.
-        name: &'a str,
-    },
-    /// The alias is to an export of a module instance.
-    CoreInstanceExport {
-        /// The alias kind.
-        kind: ExternalKind,
-        /// The instance index.
-        instance_index: u32,
-        /// The export name.
-        name: &'a str,
-    },
-    /// The alias is to an outer item.
-    Outer {
-        /// The alias kind.
-        kind: ComponentOuterAliasKind,
-        /// The outward count, starting at zero for the current component.
-        count: u32,
-        /// The index of the item within the outer component.
-        index: u32,
-    },
-}
-
-/// Section reader for the component alias section
-pub type ComponentAliasSectionReader<'a> = crate::SectionLimited<'a, ComponentAlias<'a>>;
-
-impl<'a> FromReader<'a> for ComponentAlias<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        // We don't know what type of alias it is yet, so just read the sort bytes
-        let offset = reader.original_position();
-        let byte1 = reader.read_u8()?;
-        let byte2 = if byte1 == 0x00 {
-            Some(reader.read_u8()?)
-        } else {
-            None
-        };
-
-        Ok(match reader.read_u8()? {
-            0x00 => ComponentAlias::InstanceExport {
-                kind: ComponentExternalKind::from_bytes(byte1, byte2, offset)?,
-                instance_index: reader.read_var_u32()?,
-                name: reader.read_string()?,
-            },
-            0x01 => ComponentAlias::CoreInstanceExport {
-                kind: BinaryReader::external_kind_from_byte(
-                    byte2.ok_or_else(|| {
-                        BinaryReader::invalid_leading_byte_error(
-                            byte1,
-                            "core instance export kind",
-                            offset,
-                        )
-                    })?,
-                    offset,
-                )?,
-                instance_index: reader.read_var_u32()?,
-                name: reader.read_string()?,
-            },
-            0x02 => ComponentAlias::Outer {
-                kind: component_outer_alias_kind_from_bytes(byte1, byte2, offset)?,
-                count: reader.read_var_u32()?,
-                index: reader.read_var_u32()?,
-            },
-            x => reader.invalid_leading_byte(x, "alias")?,
-        })
-    }
-}
-
-fn component_outer_alias_kind_from_bytes(
-    byte1: u8,
-    byte2: Option<u8>,
-    offset: usize,
-) -> Result<ComponentOuterAliasKind> {
-    Ok(match byte1 {
-        0x00 => match byte2.unwrap() {
-            0x10 => ComponentOuterAliasKind::CoreType,
-            0x11 => ComponentOuterAliasKind::CoreModule,
-            x => {
-                return Err(BinaryReader::invalid_leading_byte_error(
-                    x,
-                    "component outer alias kind",
-                    offset + 1,
-                ))
-            }
-        },
-        0x03 => ComponentOuterAliasKind::Type,
-        0x04 => ComponentOuterAliasKind::Component,
-        x => {
-            return Err(BinaryReader::invalid_leading_byte_error(
-                x,
-                "component outer alias kind",
-                offset,
-            ))
-        }
-    })
-}

data/ext/cargo-vendor/wasmparser-0.215.0/src/readers/component/canonicals.rs

@@ -1,121 +0,0 @@
-use crate::limits::MAX_WASM_CANONICAL_OPTIONS;
-use crate::prelude::*;
-use crate::{BinaryReader, FromReader, Result, SectionLimited};
-
-/// Represents options for component functions.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum CanonicalOption {
-    /// The string types in the function signature are UTF-8 encoded.
-    UTF8,
-    /// The string types in the function signature are UTF-16 encoded.
-    UTF16,
-    /// The string types in the function signature are compact UTF-16 encoded.
-    CompactUTF16,
-    /// The memory to use if the lifting or lowering of a function requires memory access.
-    ///
-    /// The value is an index to a core memory.
-    Memory(u32),
-    /// The realloc function to use if the lifting or lowering of a function requires memory
-    /// allocation.
-    ///
-    /// The value is an index to a core function of type `(func (param i32 i32 i32 i32) (result i32))`.
-    Realloc(u32),
-    /// The post-return function to use if the lifting of a function requires
-    /// cleanup after the function returns.
-    PostReturn(u32),
-}
-
-/// Represents a canonical function in a WebAssembly component.
-#[derive(Debug, Clone)]
-pub enum CanonicalFunction {
-    /// The function lifts a core WebAssembly function to the canonical ABI.
-    Lift {
-        /// The index of the core WebAssembly function to lift.
-        core_func_index: u32,
-        /// The index of the lifted function's type.
-        type_index: u32,
-        /// The canonical options for the function.
-        options: Box<[CanonicalOption]>,
-    },
-    /// The function lowers a canonical ABI function to a core WebAssembly function.
-    Lower {
-        /// The index of the function to lower.
-        func_index: u32,
-        /// The canonical options for the function.
-        options: Box<[CanonicalOption]>,
-    },
-    /// A function which creates a new owned handle to a resource.
-    ResourceNew {
-        /// The type index of the resource that's being created.
-        resource: u32,
-    },
-    /// A function which is used to drop resource handles of the specified type.
-    ResourceDrop {
-        /// The type index of the resource that's being dropped.
-        resource: u32,
-    },
-    /// A function which returns the underlying i32-based representation of the
-    /// specified resource.
-    ResourceRep {
-        /// The type index of the resource that's being accessed.
-        resource: u32,
-    },
-}
-
-/// A reader for the canonical section of a WebAssembly component.
-pub type ComponentCanonicalSectionReader<'a> = SectionLimited<'a, CanonicalFunction>;
-
-impl<'a> FromReader<'a> for CanonicalFunction {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<CanonicalFunction> {
-        Ok(match reader.read_u8()? {
-            0x00 => match reader.read_u8()? {
-                0x00 => {
-                    let core_func_index = reader.read_var_u32()?;
-                    let options = reader
-                        .read_iter(MAX_WASM_CANONICAL_OPTIONS, "canonical options")?
-                        .collect::<Result<_>>()?;
-                    let type_index = reader.read_var_u32()?;
-                    CanonicalFunction::Lift {
-                        core_func_index,
-                        options,
-                        type_index,
-                    }
-                }
-                x => return reader.invalid_leading_byte(x, "canonical function lift"),
-            },
-            0x01 => match reader.read_u8()? {
-                0x00 => CanonicalFunction::Lower {
-                    func_index: reader.read_var_u32()?,
-                    options: reader
-                        .read_iter(MAX_WASM_CANONICAL_OPTIONS, "canonical options")?
-                        .collect::<Result<_>>()?,
-                },
-                x => return reader.invalid_leading_byte(x, "canonical function lower"),
-            },
-            0x02 => CanonicalFunction::ResourceNew {
-                resource: reader.read()?,
-            },
-            0x03 => CanonicalFunction::ResourceDrop {
-                resource: reader.read()?,
-            },
-            0x04 => CanonicalFunction::ResourceRep {
-                resource: reader.read()?,
-            },
-            x => return reader.invalid_leading_byte(x, "canonical function"),
-        })
-    }
-}
-
-impl<'a> FromReader<'a> for CanonicalOption {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(match reader.read_u8()? {
-            0x00 => CanonicalOption::UTF8,
-            0x01 => CanonicalOption::UTF16,
-            0x02 => CanonicalOption::CompactUTF16,
-            0x03 => CanonicalOption::Memory(reader.read_var_u32()?),
-            0x04 => CanonicalOption::Realloc(reader.read_var_u32()?),
-            0x05 => CanonicalOption::PostReturn(reader.read_var_u32()?),
-            x => return reader.invalid_leading_byte(x, "canonical option"),
-        })
-    }
-}

data/ext/cargo-vendor/wasmparser-0.215.0/src/readers/component/exports.rs

@@ -1,135 +0,0 @@
-use crate::{BinaryReader, ComponentTypeRef, FromReader, Result, SectionLimited};
-
-/// Represents the kind of an external items of a WebAssembly component.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum ComponentExternalKind {
-    /// The external kind is a core module.
-    Module,
-    /// The external kind is a function.
-    Func,
-    /// The external kind is a value.
-    Value,
-    /// The external kind is a type.
-    Type,
-    /// The external kind is an instance.
-    Instance,
-    /// The external kind is a component.
-    Component,
-}
-
-impl ComponentExternalKind {
-    pub(crate) fn from_bytes(
-        byte1: u8,
-        byte2: Option<u8>,
-        offset: usize,
-    ) -> Result<ComponentExternalKind> {
-        Ok(match byte1 {
-            0x00 => match byte2.unwrap() {
-                0x11 => ComponentExternalKind::Module,
-                x => {
-                    return Err(BinaryReader::invalid_leading_byte_error(
-                        x,
-                        "component external kind",
-                        offset + 1,
-                    ))
-                }
-            },
-            0x01 => ComponentExternalKind::Func,
-            0x02 => ComponentExternalKind::Value,
-            0x03 => ComponentExternalKind::Type,
-            0x04 => ComponentExternalKind::Component,
-            0x05 => ComponentExternalKind::Instance,
-            x => {
-                return Err(BinaryReader::invalid_leading_byte_error(
-                    x,
-                    "component external kind",
-                    offset,
-                ))
-            }
-        })
-    }
-
-    /// Returns a simple string description of this kind.
-    pub fn desc(&self) -> &'static str {
-        use ComponentExternalKind::*;
-        match self {
-            Module => "module",
-            Func => "func",
-            Value => "value",
-            Type => "type",
-            Instance => "instance",
-            Component => "component",
-        }
-    }
-}
-
-/// Represents an export in a WebAssembly component.
-#[derive(Debug, Clone)]
-pub struct ComponentExport<'a> {
-    /// The name of the exported item.
-    pub name: ComponentExportName<'a>,
-    /// The kind of the export.
-    pub kind: ComponentExternalKind,
-    /// The index of the exported item.
-    pub index: u32,
-    /// An optionally specified type ascribed to this export.
-    pub ty: Option<ComponentTypeRef>,
-}
-
-/// A reader for the export section of a WebAssembly component.
-pub type ComponentExportSectionReader<'a> = SectionLimited<'a, ComponentExport<'a>>;
-
-impl<'a> FromReader<'a> for ComponentExport<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(ComponentExport {
-            name: reader.read()?,
-            kind: reader.read()?,
-            index: reader.read()?,
-            ty: match reader.read_u8()? {
-                0x00 => None,
-                0x01 => Some(reader.read()?),
-                other => {
-                    return Err(BinaryReader::invalid_leading_byte_error(
-                        other,
-                        "optional component export type",
-                        reader.original_position() - 1,
-                    ))
-                }
-            },
-        })
-    }
-}
-
-impl<'a> FromReader<'a> for ComponentExternalKind {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        let offset = reader.original_position();
-        let byte1 = reader.read_u8()?;
-        let byte2 = if byte1 == 0x00 {
-            Some(reader.read_u8()?)
-        } else {
-            None
-        };
-
-        ComponentExternalKind::from_bytes(byte1, byte2, offset)
-    }
-}
-
-/// Represents the name of a component export.
-#[derive(Debug, Copy, Clone)]
-#[allow(missing_docs)]
-pub struct ComponentExportName<'a>(pub &'a str);
-
-impl<'a> FromReader<'a> for ComponentExportName<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        match reader.read_u8()? {
-            0x00 => {}
-            // Historically export names used a discriminator byte of 0x01 to
-            // indicate an "interface" of the form `a:b/c` but nowadays that's
-            // inferred from string syntax. Ignore 0-vs-1 to continue to parse
-            // older binaries. Eventually this will go away.
-            0x01 => {}
-            x => return reader.invalid_leading_byte(x, "export name"),
-        }
-        Ok(ComponentExportName(reader.read_string()?))
-    }
-}

data/ext/cargo-vendor/wasmparser-0.215.0/src/readers/component/imports.rs

@@ -1,130 +0,0 @@
-use crate::{
-    BinaryReader, ComponentExternalKind, ComponentValType, FromReader, Result, SectionLimited,
-};
-
-/// Represents the type bounds for imports and exports.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum TypeBounds {
-    /// The type is bounded by equality.
-    Eq(u32),
-    /// A fresh resource type,
-    SubResource,
-}
-
-impl<'a> FromReader<'a> for TypeBounds {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(match reader.read_u8()? {
-            0x00 => TypeBounds::Eq(reader.read()?),
-            0x01 => TypeBounds::SubResource,
-            x => return reader.invalid_leading_byte(x, "type bound"),
-        })
-    }
-}
-
-/// Represents a reference to a component type.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum ComponentTypeRef {
-    /// The reference is to a core module type.
-    ///
-    /// The index is expected to be core type index to a core module type.
-    Module(u32),
-    /// The reference is to a function type.
-    ///
-    /// The index is expected to be a type index to a function type.
-    Func(u32),
-    /// The reference is to a value type.
-    Value(ComponentValType),
-    /// The reference is to a bounded type.
-    ///
-    /// The index is expected to be a type index.
-    Type(TypeBounds),
-    /// The reference is to an instance type.
-    ///
-    /// The index is a type index to an instance type.
-    Instance(u32),
-    /// The reference is to a component type.
-    ///
-    /// The index is a type index to a component type.
-    Component(u32),
-}
-
-impl ComponentTypeRef {
-    /// Returns the corresponding [`ComponentExternalKind`] for this reference.
-    pub fn kind(&self) -> ComponentExternalKind {
-        match self {
-            ComponentTypeRef::Module(_) => ComponentExternalKind::Module,
-            ComponentTypeRef::Func(_) => ComponentExternalKind::Func,
-            ComponentTypeRef::Value(_) => ComponentExternalKind::Value,
-            ComponentTypeRef::Type(..) => ComponentExternalKind::Type,
-            ComponentTypeRef::Instance(_) => ComponentExternalKind::Instance,
-            ComponentTypeRef::Component(_) => ComponentExternalKind::Component,
-        }
-    }
-}
-
-impl<'a> FromReader<'a> for ComponentTypeRef {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(match reader.read()? {
-            ComponentExternalKind::Module => ComponentTypeRef::Module(reader.read()?),
-            ComponentExternalKind::Func => ComponentTypeRef::Func(reader.read()?),
-            ComponentExternalKind::Value => ComponentTypeRef::Value(reader.read()?),
-            ComponentExternalKind::Type => ComponentTypeRef::Type(reader.read()?),
-            ComponentExternalKind::Instance => ComponentTypeRef::Instance(reader.read()?),
-            ComponentExternalKind::Component => ComponentTypeRef::Component(reader.read()?),
-        })
-    }
-}
-
-/// Represents an import in a WebAssembly component
-#[derive(Debug, Copy, Clone)]
-pub struct ComponentImport<'a> {
-    /// The name of the imported item.
-    pub name: ComponentImportName<'a>,
-    /// The type reference for the import.
-    pub ty: ComponentTypeRef,
-}
-
-impl<'a> FromReader<'a> for ComponentImport<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(ComponentImport {
-            name: reader.read()?,
-            ty: reader.read()?,
-        })
-    }
-}
-
-/// A reader for the import section of a WebAssembly component.
-///
-/// # Examples
-///
-/// ```
-/// use wasmparser::{ComponentImportSectionReader, BinaryReader, WasmFeatures};
-/// let data: &[u8] = &[0x01, 0x00, 0x01, 0x41, 0x01, 0x66];
-/// let reader = BinaryReader::new(data, 0, WasmFeatures::all());
-/// let reader = ComponentImportSectionReader::new(reader).unwrap();
-/// for import in reader {
-///     let import = import.expect("import");
-///     println!("Import: {:?}", import);
-/// }
-/// ```
-pub type ComponentImportSectionReader<'a> = SectionLimited<'a, ComponentImport<'a>>;
-
-/// Represents the name of a component import.
-#[derive(Debug, Copy, Clone)]
-#[allow(missing_docs)]
-pub struct ComponentImportName<'a>(pub &'a str);
-
-impl<'a> FromReader<'a> for ComponentImportName<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        match reader.read_u8()? {
-            0x00 => {}
-            // Historically export names used a discriminator byte of 0x01 to
-            // indicate an "interface" of the form `a:b/c` but nowadays that's
-            // inferred from string syntax. Ignore 0-vs-1 to continue to parse
-            // older binaries. Eventually this will go away.
-            0x01 => {}
-            x => return reader.invalid_leading_byte(x, "import name"),
-        }
-        Ok(ComponentImportName(reader.read_string()?))
-    }
-}

data/ext/cargo-vendor/wasmparser-0.215.0/src/readers/component/instances.rs

@@ -1,166 +0,0 @@
-use crate::limits::{MAX_WASM_INSTANTIATION_ARGS, MAX_WASM_INSTANTIATION_EXPORTS};
-use crate::prelude::*;
-use crate::{
-    BinaryReader, ComponentExport, ComponentExternalKind, Export, FromReader, Result,
-    SectionLimited,
-};
-
-/// Represents the kind of an instantiation argument for a core instance.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum InstantiationArgKind {
-    /// The instantiation argument is a core instance.
-    Instance,
-}
-
-/// Represents an argument to instantiating a WebAssembly module.
-#[derive(Debug, Clone)]
-pub struct InstantiationArg<'a> {
-    /// The name of the module argument.
-    pub name: &'a str,
-    /// The kind of the module argument.
-    pub kind: InstantiationArgKind,
-    /// The index of the argument item.
-    pub index: u32,
-}
-
-/// Represents an instance of a WebAssembly module.
-#[derive(Debug, Clone)]
-pub enum Instance<'a> {
-    /// The instance is from instantiating a WebAssembly module.
-    Instantiate {
-        /// The module index.
-        module_index: u32,
-        /// The module's instantiation arguments.
-        args: Box<[InstantiationArg<'a>]>,
-    },
-    /// The instance is a from exporting local items.
-    FromExports(Box<[Export<'a>]>),
-}
-
-/// A reader for the core instance section of a WebAssembly component.
-///
-/// # Examples
-///
-/// ```
-/// use wasmparser::{InstanceSectionReader, BinaryReader, WasmFeatures};
-/// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x01, 0x03, b'f', b'o', b'o', 0x12, 0x00];
-/// let reader = BinaryReader::new(data, 0, WasmFeatures::all());
-/// let mut reader = InstanceSectionReader::new(reader).unwrap();
-/// for inst in reader {
-///     println!("Instance {:?}", inst.expect("instance"));
-/// }
-/// ```
-pub type InstanceSectionReader<'a> = SectionLimited<'a, Instance<'a>>;
-
-impl<'a> FromReader<'a> for Instance<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(match reader.read_u8()? {
-            0x00 => Instance::Instantiate {
-                module_index: reader.read_var_u32()?,
-                args: reader
-                    .read_iter(MAX_WASM_INSTANTIATION_ARGS, "core instantiation arguments")?
-                    .collect::<Result<_>>()?,
-            },
-            0x01 => Instance::FromExports(
-                reader
-                    .read_iter(MAX_WASM_INSTANTIATION_ARGS, "core instantiation arguments")?
-                    .collect::<Result<_>>()?,
-            ),
-            x => return reader.invalid_leading_byte(x, "core instance"),
-        })
-    }
-}
-
-impl<'a> FromReader<'a> for InstantiationArg<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(InstantiationArg {
-            name: reader.read()?,
-            kind: reader.read()?,
-            index: reader.read()?,
-        })
-    }
-}
-
-impl<'a> FromReader<'a> for InstantiationArgKind {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(match reader.read_u8()? {
-            0x12 => InstantiationArgKind::Instance,
-            x => return reader.invalid_leading_byte(x, "instantiation arg kind"),
-        })
-    }
-}
-
-/// Represents an argument to instantiating a WebAssembly component.
-#[derive(Debug, Clone)]
-pub struct ComponentInstantiationArg<'a> {
-    /// The name of the component argument.
-    pub name: &'a str,
-    /// The kind of the component argument.
-    pub kind: ComponentExternalKind,
-    /// The index of the argument item.
-    pub index: u32,
-}
-
-/// Represents an instance in a WebAssembly component.
-#[derive(Debug, Clone)]
-pub enum ComponentInstance<'a> {
-    /// The instance is from instantiating a WebAssembly component.
-    Instantiate {
-        /// The component index.
-        component_index: u32,
-        /// The component's instantiation arguments.
-        args: Box<[ComponentInstantiationArg<'a>]>,
-    },
-    /// The instance is a from exporting local items.
-    FromExports(Box<[ComponentExport<'a>]>),
-}
-
-/// A reader for the component instance section of a WebAssembly component.
-///
-/// # Examples
-///
-/// ```
-/// use wasmparser::{ComponentInstanceSectionReader, BinaryReader, WasmFeatures};
-/// # let data: &[u8] = &[0x01, 0x00, 0x00, 0x01, 0x03, b'f', b'o', b'o', 0x01, 0x00];
-/// let reader = BinaryReader::new(data, 0, WasmFeatures::all());
-/// let mut reader = ComponentInstanceSectionReader::new(reader).unwrap();
-/// for inst in reader {
-///     println!("Instance {:?}", inst.expect("instance"));
-/// }
-/// ```
-pub type ComponentInstanceSectionReader<'a> = SectionLimited<'a, ComponentInstance<'a>>;
-
-impl<'a> FromReader<'a> for ComponentInstance<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(match reader.read_u8()? {
-            0x00 => ComponentInstance::Instantiate {
-                component_index: reader.read_var_u32()?,
-                args: reader
-                    .read_iter(MAX_WASM_INSTANTIATION_ARGS, "instantiation arguments")?
-                    .collect::<Result<_>>()?,
-            },
-            0x01 => ComponentInstance::FromExports(
-                (0..reader.read_size(MAX_WASM_INSTANTIATION_EXPORTS, "instantiation exports")?)
-                    .map(|_| {
-                        Ok(ComponentExport {
-                            name: reader.read()?,
-                            kind: reader.read()?,
-                            index: reader.read()?,
-                            ty: None,
-                        })
-                    })
-                    .collect::<Result<_>>()?,
-            ),
-            x => return reader.invalid_leading_byte(x, "instance"),
-        })
-    }
-}
-impl<'a> FromReader<'a> for ComponentInstantiationArg<'a> {
-    fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(ComponentInstantiationArg {
-            name: reader.read()?,
-            kind: reader.read()?,
-            index: reader.read()?,
-        })
-    }
-}