wasmtime 24.0.0 → 25.0.0

data/ext/cargo-vendor/wasmtime-component-macro-25.0.0/tests/expanded/worlds-with-types_async.rs

@@ -0,0 +1,279 @@
+pub type U = foo::foo::i::T;
+const _: () = {
+    assert!(2 == < U as wasmtime::component::ComponentType >::SIZE32);
+    assert!(2 == < U as wasmtime::component::ComponentType >::ALIGN32);
+};
+pub type T = u32;
+const _: () = {
+    assert!(4 == < T as wasmtime::component::ComponentType >::SIZE32);
+    assert!(4 == < T as wasmtime::component::ComponentType >::ALIGN32);
+};
+#[derive(wasmtime::component::ComponentType)]
+#[derive(wasmtime::component::Lift)]
+#[derive(wasmtime::component::Lower)]
+#[component(record)]
+#[derive(Clone, Copy)]
+pub struct R {}
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("R").finish()
+    }
+}
+const _: () = {
+    assert!(0 == < R as wasmtime::component::ComponentType >::SIZE32);
+    assert!(1 == < R as wasmtime::component::ComponentType >::ALIGN32);
+};
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {
+    f: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate_async`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {
+    f: wasmtime::component::Func,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let f = _component
+                .export_index(None, "f")
+                .ok_or_else(|| anyhow::anyhow!("no function export `f` found"))?
+                .1;
+            Ok(FooIndices { f })
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let f = _instance
+                .get_export(&mut store, None, "f")
+                .ok_or_else(|| anyhow::anyhow!("no function export `f` found"))?;
+            Ok(FooIndices { f })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            let f = *_instance
+                .get_typed_func::<(), ((T, U, R),)>(&mut store, &self.f)?
+                .func();
+            Ok(Foo { f })
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::i::Host + Send,
+        {
+            foo::foo::i::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub async fn call_f<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<(T, U, R)>
+        where
+            <S as wasmtime::AsContext>::Data: Send,
+        {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<(), ((T, U, R),)>::new_unchecked(self.f)
+            };
+            let (ret0,) = callee.call_async(store.as_context_mut(), ()).await?;
+            callee.post_return_async(store.as_context_mut()).await?;
+            Ok(ret0)
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod i {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type T = u16;
+            const _: () = {
+                assert!(2 == < T as wasmtime::component::ComponentType >::SIZE32);
+                assert!(2 == < T as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/i")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-component-macro-25.0.0/tests/expanded/worlds-with-types_tracing_async.rs

@@ -0,0 +1,287 @@
+pub type U = foo::foo::i::T;
+const _: () = {
+    assert!(2 == < U as wasmtime::component::ComponentType >::SIZE32);
+    assert!(2 == < U as wasmtime::component::ComponentType >::ALIGN32);
+};
+pub type T = u32;
+const _: () = {
+    assert!(4 == < T as wasmtime::component::ComponentType >::SIZE32);
+    assert!(4 == < T as wasmtime::component::ComponentType >::ALIGN32);
+};
+#[derive(wasmtime::component::ComponentType)]
+#[derive(wasmtime::component::Lift)]
+#[derive(wasmtime::component::Lower)]
+#[component(record)]
+#[derive(Clone, Copy)]
+pub struct R {}
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("R").finish()
+    }
+}
+const _: () = {
+    assert!(0 == < R as wasmtime::component::ComponentType >::SIZE32);
+    assert!(1 == < R as wasmtime::component::ComponentType >::ALIGN32);
+};
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {
+    f: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate_async`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {
+    f: wasmtime::component::Func,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let f = _component
+                .export_index(None, "f")
+                .ok_or_else(|| anyhow::anyhow!("no function export `f` found"))?
+                .1;
+            Ok(FooIndices { f })
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let f = _instance
+                .get_export(&mut store, None, "f")
+                .ok_or_else(|| anyhow::anyhow!("no function export `f` found"))?;
+            Ok(FooIndices { f })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            let f = *_instance
+                .get_typed_func::<(), ((T, U, R),)>(&mut store, &self.f)?
+                .func();
+            Ok(Foo { f })
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::i::Host + Send,
+        {
+            foo::foo::i::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub async fn call_f<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<(T, U, R)>
+        where
+            <S as wasmtime::AsContext>::Data: Send,
+        {
+            use tracing::Instrument;
+            let span = tracing::span!(
+                tracing::Level::TRACE, "wit-bindgen export", module = "default", function
+                = "f",
+            );
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<(), ((T, U, R),)>::new_unchecked(self.f)
+            };
+            let (ret0,) = callee
+                .call_async(store.as_context_mut(), ())
+                .instrument(span.clone())
+                .await?;
+            callee.post_return_async(store.as_context_mut()).instrument(span).await?;
+            Ok(ret0)
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod i {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type T = u16;
+            const _: () = {
+                assert!(2 == < T as wasmtime::component::ComponentType >::SIZE32);
+                assert!(2 == < T as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/i")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+    }
+}

data/ext/cargo-vendor/wasmtime-component-macro-25.0.0/tests/expanded.rs

@@ -0,0 +1,72 @@
+use std::path::Path;
+
+use anyhow::{bail, Context, Result};
+
+macro_rules! genexpand {
+    ($id:ident $name:tt $path:tt) => {
+        process_expanded($path, "", wasmtime::component::bindgen!({
+            path: $path,
+            stringify: true,
+        }))?;
+
+        process_expanded($path, "_async", wasmtime::component::bindgen!({
+            path: $path,
+            async: true,
+            stringify: true,
+        }))?;
+
+        process_expanded($path, "_tracing_async", wasmtime::component::bindgen!({
+            path: $path,
+            async: true,
+            tracing: true,
+            stringify: true,
+        }))?;
+    };
+}
+
+fn process_expanded(path: &str, suffix: &str, src: &str) -> Result<()> {
+    let formatted_src = {
+        let syn_file = syn::parse_file(src).unwrap();
+        prettyplease::unparse(&syn_file)
+    };
+    let expanded_path = {
+        let mut stem = Path::new(path).file_stem().unwrap().to_os_string();
+        stem.push(suffix);
+        Path::new("tests/expanded").join(stem).with_extension("rs")
+    };
+    if std::env::var("BINDGEN_TEST_BLESS").is_ok_and(|val| !val.is_empty()) {
+        std::fs::write(expanded_path, formatted_src)?;
+    } else {
+        match std::fs::read_to_string(&expanded_path) {
+            Ok(expected) if formatted_src == expected => (),
+            Ok(expected) => {
+                bail!(
+                    "checked-in expanded bindings from {expanded_path:?} \
+                    do not match those generated from {path:?}
+                    \n\
+                    {diff}\n\
+                    \n\
+                    This test assertion can be automatically updated by setting the\n\
+                    BINDGEN_TEST_BLESS=1 environment variable when running this test.",
+                    diff = similar::TextDiff::from_lines(&expected, &formatted_src)
+                        .unified_diff()
+                        .header("expected", "actual")
+                )
+            }
+            Err(err) => {
+                return Err(err).with_context(|| {
+                    format!(
+                    "failed to read {expanded_path:?}; re-run with BINDGEN_TEST_BLESS=1 to create"
+                )
+                })
+            }
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn expand_wits() -> Result<()> {
+    component_macro_test_helpers::foreach!(genexpand);
+    Ok(())
+}

data/ext/cargo-vendor/wasmtime-component-util-25.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"d3baa3e13b17f656d2177baa8f756af6a8f5eb017c0bcd9572f5ce9e6d305b87","src/lib.rs":"1edf46602f956fc57d78727d2c3ed8b7a1e179906f72985e4c41603b044daf85"},"package":"8553d3720625ad4e65a9c71e215566361fcefc4e4001f17e7c669c503c33e6f6"}

data/ext/cargo-vendor/wasmtime-component-util-25.0.0/Cargo.toml

@@ -0,0 +1,36 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.78.0"
+name = "wasmtime-component-util"
+version = "25.0.0"
+authors = ["The Wasmtime Project Developers"]
+build = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Utility types and functions to support the component model in Wasmtime"
+documentation = "https://docs.rs/wasmtime-component-util/"
+readme = false
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lib]
+name = "wasmtime_component_util"
+path = "src/lib.rs"

data/ext/cargo-vendor/wasmtime-cranelift-25.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"53e65974eb0750c91a16af992124d4b30297e1d0e0196120b870af3b57a4a40f","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","SECURITY.md":"88ef39090879a80611c6ebfbefc1a71950f0e0f15258e953f329fba9afa56db6","src/builder.rs":"7392953f146aedf492f893665bd5da578aeba8ba66e209af40e7cf6b0e5e4e87","src/compiled_function.rs":"cfdce680cf8788143e784faeb4dc3f93a30872e81f64903c357c430cefefb3c4","src/compiler.rs":"dc514c09c41537399c2455492f35e43a0f11fcceec73f7bc94f346449456c8a6","src/compiler/component.rs":"01fe62a247cdea8e16dac7285957b4a3a18ab4ee88f449e3b2704e53d3969298","src/debug.rs":"0a9ed56c1fb6a4c5024d3b9eba996f28cc0ef7c1d2960a375d2b0c154f44f7a5","src/debug/gc.rs":"132ce0fed235670064b0eaf10d40eb8845ae63029484447e6939ec7f815fa34c","src/debug/transform/address_transform.rs":"a6163a67cba6f0c9200ef710b35254d448adcb1518893c90d538741b976551ed","src/debug/transform/attr.rs":"fa559de6ad549265fa37352ddbf10a79fa5a221da2b833e93fff3a2266a45491","src/debug/transform/expression.rs":"0b430d2ecff557e73d5d365ed6985253bb5eac90be981fbe70a721c25e2597df","src/debug/transform/line_program.rs":"c608aa675656d45a849cdac3777d22e69fb6fab153e6194de34ae9fb9fd0e2ae","src/debug/transform/mod.rs":"5d7fab74b5681e0a0992a1f4cb0d62fb906ed0b2f079d6169fbb08dac17255fc","src/debug/transform/range_info_builder.rs":"467c89c17ff8175637c019716cc17705d06bf71e1772ab0ac75f9380e7d1f2c4","src/debug/transform/refs.rs":"f50c58de74ef59f69b5df24b8e62da7ee6ea1ab09c536eae4eea3a0c9744dfd9","src/debug/transform/simulate.rs":"26ff441f6abcb1bda1b12122b911e4d79feba6ef18b8e3f24698e3906f5ffbbd","src/debug/transform/unit.rs":"8c625dbafd2a4562f0ed6051e60ba5cc13d76763d296c3cd32d96b82df233c57","src/debug/transform/utils.rs":"14d3f7bfb7f563544ecb5fa7baab6460fac28f283f230988911fcca18536f4ab","src/debug/write_debuginfo.rs":"1858d0d33e44752b69f651326870515b4e61f2cab2a656396851b32c04d0ce91","src/func_environ.rs":"80e1913f24aee6c05433e8e22d825c6bc674a2f69b10ffea5eccd92fee827648","src/gc.rs":"686bca3844734b80fb7cb40274f22431dd77b133dd0fd2b1aa73116c33a44b54","src/gc/disabled.rs":"b591300cb471790ca549809d4e8a83304ae17669532f92bf8e50b961347c724b","src/gc/enabled.rs":"f10108ed9fc529e2c57bab91c0eb8a0407aac9b2113a5f0d91cb737b4a4d00fa","src/isa_builder.rs":"2134795641afb82a3aff375014fa9a0c4f600a3a01bd4c624f03e01d149a2ab5","src/lib.rs":"25a7fe55f174d3aa83e5f91adcf68a9e6bc113b764bc31c50b62c03b8ac240e0","src/obj.rs":"b23437fd6d56c4cf747352abd2274ed29359d9084f807734e83300a42b0e9399"},"package":"1b1b81791925aa182f0816562b8b41b9546077ba3a789ca18454a3ffe083963a"}