wasmtime 9.0.4 → 10.0.1

data/ext/cargo-vendor/wasmtime-10.0.1/src/values.rs

@@ -0,0 +1,290 @@
+use crate::r#ref::ExternRef;
+use crate::store::StoreOpaque;
+use crate::{AsContextMut, Func, ValType};
+use anyhow::{bail, Result};
+use std::ptr;
+use wasmtime_runtime::TableElement;
+
+pub use wasmtime_runtime::ValRaw;
+
+/// Possible runtime values that a WebAssembly module can either consume or
+/// produce.
+#[derive(Debug, Clone)]
+pub enum Val {
+    // NB: the ordering here is intended to match the ordering in
+    // `ValType` to improve codegen when learning the type of a value.
+    /// A 32-bit integer
+    I32(i32),
+
+    /// A 64-bit integer
+    I64(i64),
+
+    /// A 32-bit float.
+    ///
+    /// Note that the raw bits of the float are stored here, and you can use
+    /// `f32::from_bits` to create an `f32` value.
+    F32(u32),
+
+    /// A 64-bit float.
+    ///
+    /// Note that the raw bits of the float are stored here, and you can use
+    /// `f64::from_bits` to create an `f64` value.
+    F64(u64),
+
+    /// A 128-bit number
+    V128(u128),
+
+    /// A first-class reference to a WebAssembly function.
+    ///
+    /// `FuncRef(None)` is the null function reference, created by `ref.null
+    /// func` in Wasm.
+    FuncRef(Option<Func>),
+
+    /// An `externref` value which can hold opaque data to the Wasm instance
+    /// itself.
+    ///
+    /// `ExternRef(None)` is the null external reference, created by `ref.null
+    /// extern` in Wasm.
+    ExternRef(Option<ExternRef>),
+}
+
+macro_rules! accessors {
+    ($bind:ident $(($variant:ident($ty:ty) $get:ident $unwrap:ident $cvt:expr))*) => ($(
+        /// Attempt to access the underlying value of this `Val`, returning
+        /// `None` if it is not the correct type.
+        #[inline]
+        pub fn $get(&self) -> Option<$ty> {
+            if let Val::$variant($bind) = self {
+                Some($cvt)
+            } else {
+                None
+            }
+        }
+
+        /// Returns the underlying value of this `Val`, panicking if it's the
+        /// wrong type.
+        ///
+        /// # Panics
+        ///
+        /// Panics if `self` is not of the right type.
+        #[inline]
+        pub fn $unwrap(&self) -> $ty {
+            self.$get().expect(concat!("expected ", stringify!($ty)))
+        }
+    )*)
+}
+
+impl Val {
+    /// Returns a null `externref` value.
+    #[inline]
+    pub fn null() -> Val {
+        Val::ExternRef(None)
+    }
+
+    /// Returns the corresponding [`ValType`] for this `Val`.
+    #[inline]
+    pub fn ty(&self) -> ValType {
+        match self {
+            Val::I32(_) => ValType::I32,
+            Val::I64(_) => ValType::I64,
+            Val::F32(_) => ValType::F32,
+            Val::F64(_) => ValType::F64,
+            Val::ExternRef(_) => ValType::ExternRef,
+            Val::FuncRef(_) => ValType::FuncRef,
+            Val::V128(_) => ValType::V128,
+        }
+    }
+
+    /// Convenience method to convert this [`Val`] into a [`ValRaw`].
+    ///
+    /// # Unsafety
+    ///
+    /// This method is unsafe for the reasons that [`ExternRef::to_raw`] and
+    /// [`Func::to_raw`] are unsafe.
+    pub unsafe fn to_raw(&self, store: impl AsContextMut) -> ValRaw {
+        match self {
+            Val::I32(i) => ValRaw::i32(*i),
+            Val::I64(i) => ValRaw::i64(*i),
+            Val::F32(u) => ValRaw::f32(*u),
+            Val::F64(u) => ValRaw::f64(*u),
+            Val::V128(b) => ValRaw::v128(*b),
+            Val::ExternRef(e) => {
+                let externref = match e {
+                    Some(e) => e.to_raw(store),
+                    None => ptr::null_mut(),
+                };
+                ValRaw::externref(externref)
+            }
+            Val::FuncRef(f) => {
+                let funcref = match f {
+                    Some(f) => f.to_raw(store),
+                    None => ptr::null_mut(),
+                };
+                ValRaw::funcref(funcref)
+            }
+        }
+    }
+
+    /// Convenience method to convert a [`ValRaw`] into a [`Val`].
+    ///
+    /// # Unsafety
+    ///
+    /// This method is unsafe for the reasons that [`ExternRef::from_raw`] and
+    /// [`Func::from_raw`] are unsafe. Additionaly there's no guarantee
+    /// otherwise that `raw` should have the type `ty` specified.
+    pub unsafe fn from_raw(store: impl AsContextMut, raw: ValRaw, ty: ValType) -> Val {
+        match ty {
+            ValType::I32 => Val::I32(raw.get_i32()),
+            ValType::I64 => Val::I64(raw.get_i64()),
+            ValType::F32 => Val::F32(raw.get_f32()),
+            ValType::F64 => Val::F64(raw.get_f64()),
+            ValType::V128 => Val::V128(raw.get_v128()),
+            ValType::ExternRef => Val::ExternRef(ExternRef::from_raw(raw.get_externref())),
+            ValType::FuncRef => Val::FuncRef(Func::from_raw(store, raw.get_funcref())),
+        }
+    }
+
+    accessors! {
+        e
+        (I32(i32) i32 unwrap_i32 *e)
+        (I64(i64) i64 unwrap_i64 *e)
+        (F32(f32) f32 unwrap_f32 f32::from_bits(*e))
+        (F64(f64) f64 unwrap_f64 f64::from_bits(*e))
+        (FuncRef(Option<&Func>) funcref unwrap_funcref e.as_ref())
+        (V128(u128) v128 unwrap_v128 *e)
+    }
+
+    /// Attempt to access the underlying `externref` value of this `Val`.
+    ///
+    /// If this is not an `externref`, then `None` is returned.
+    ///
+    /// If this is a null `externref`, then `Some(None)` is returned.
+    ///
+    /// If this is a non-null `externref`, then `Some(Some(..))` is returned.
+    #[inline]
+    pub fn externref(&self) -> Option<Option<ExternRef>> {
+        match self {
+            Val::ExternRef(e) => Some(e.clone()),
+            _ => None,
+        }
+    }
+
+    /// Returns the underlying `externref` value of this `Val`, panicking if it's the
+    /// wrong type.
+    ///
+    /// If this is a null `externref`, then `None` is returned.
+    ///
+    /// If this is a non-null `externref`, then `Some(..)` is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` is not a (nullable) `externref`.
+    #[inline]
+    pub fn unwrap_externref(&self) -> Option<ExternRef> {
+        self.externref().expect("expected externref")
+    }
+
+    pub(crate) fn into_table_element(
+        self,
+        store: &mut StoreOpaque,
+        ty: ValType,
+    ) -> Result<TableElement> {
+        match (self, ty) {
+            (Val::FuncRef(Some(f)), ValType::FuncRef) => {
+                if !f.comes_from_same_store(store) {
+                    bail!("cross-`Store` values are not supported in tables");
+                }
+                Ok(TableElement::FuncRef(
+                    f.caller_checked_func_ref(store).as_ptr(),
+                ))
+            }
+            (Val::FuncRef(None), ValType::FuncRef) => Ok(TableElement::FuncRef(ptr::null_mut())),
+            (Val::ExternRef(Some(x)), ValType::ExternRef) => {
+                Ok(TableElement::ExternRef(Some(x.inner)))
+            }
+            (Val::ExternRef(None), ValType::ExternRef) => Ok(TableElement::ExternRef(None)),
+            _ => bail!("value does not match table element type"),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        match self {
+            Val::FuncRef(Some(f)) => f.comes_from_same_store(store),
+            Val::FuncRef(None) => true,
+
+            // Integers, floats, vectors, and `externref`s have no association
+            // with any particular store, so they're always considered as "yes I
+            // came from that store",
+            Val::I32(_)
+            | Val::I64(_)
+            | Val::F32(_)
+            | Val::F64(_)
+            | Val::V128(_)
+            | Val::ExternRef(_) => true,
+        }
+    }
+}
+
+impl From<i32> for Val {
+    #[inline]
+    fn from(val: i32) -> Val {
+        Val::I32(val)
+    }
+}
+
+impl From<i64> for Val {
+    #[inline]
+    fn from(val: i64) -> Val {
+        Val::I64(val)
+    }
+}
+
+impl From<f32> for Val {
+    #[inline]
+    fn from(val: f32) -> Val {
+        Val::F32(val.to_bits())
+    }
+}
+
+impl From<f64> for Val {
+    #[inline]
+    fn from(val: f64) -> Val {
+        Val::F64(val.to_bits())
+    }
+}
+
+impl From<ExternRef> for Val {
+    #[inline]
+    fn from(val: ExternRef) -> Val {
+        Val::ExternRef(Some(val))
+    }
+}
+
+impl From<Option<ExternRef>> for Val {
+    #[inline]
+    fn from(val: Option<ExternRef>) -> Val {
+        Val::ExternRef(val)
+    }
+}
+
+impl From<Option<Func>> for Val {
+    #[inline]
+    fn from(val: Option<Func>) -> Val {
+        Val::FuncRef(val)
+    }
+}
+
+impl From<Func> for Val {
+    #[inline]
+    fn from(val: Func) -> Val {
+        Val::FuncRef(Some(val))
+    }
+}
+
+impl From<u128> for Val {
+    #[inline]
+    fn from(val: u128) -> Val {
+        Val::V128(val)
+    }
+}

data/ext/cargo-vendor/wasmtime-asm-macros-10.0.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"7dd593797fcee3cbb546ec43916c151cf59c3a49f14d0509dd9ccfacb29f49d1","src/lib.rs":"1cb36602e92d2984e218fd6c6455308018afd155754fb3801a12c06613a757ce"},"package":"284466ef356ce2d909bc0ad470b60c4d0df5df2de9084457e118131b3c779b92"}

data/ext/cargo-vendor/wasmtime-asm-macros-10.0.1/Cargo.toml

@@ -0,0 +1,22 @@
+# 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"
+name = "wasmtime-asm-macros"
+version = "10.0.1"
+authors = ["The Wasmtime Project Developers"]
+description = "Macros for defining asm functions in Wasmtime"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.cfg-if]
+version = "1.0"

data/ext/cargo-vendor/wasmtime-cache-10.0.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"bc56e0a39b0abd6678adaaff7180525dc4d03ff3890d624f1046111a1dfc4b7b","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"084a263430a3b2291e08a0d3a6df04f8803410f542e1ccadcedc0f8117449929","src/config.rs":"2ad26e96fdcf8fce2adf1ed71cd69bcc3b4248443db34829723521eb7b9299de","src/config/tests.rs":"68489ca054ee6dbe272c5c03d4d743292658cc1fe5f5a537af7c314d982238e6","src/lib.rs":"b7c08b9d82a335d23d2f51cc92ecfef3a472c491c8e7bcc4d40c66acd4f3b663","src/tests.rs":"f2e96fca0bf4007514b406c1a9c43aef3157506076348c2ca8150dfa23ad6717","src/worker.rs":"37a14488d6a971e53183d927fa5b2c70cadcb0eecfab06da206b2195689f3ef0","src/worker/tests.rs":"ea1aec7b5737165a4524308ca81e9bd09a6b08f9bcc915942bd9bc52bf019dad","src/worker/tests/system_time_stub.rs":"4fed428563563d59606a1451cd6de14bcb06d55902bb8c1a1dfae28a481ec262","tests/cache_write_default_config.rs":"e0538177c69da417d3855d96aa60f0da1e4ff8048b926727abe0b8c4d36f3785"},"package":"efc78cfe1a758d1336f447a47af6ec05e0df2c03c93440d70faf80e17fbb001e"}

data/ext/cargo-vendor/wasmtime-cache-10.0.1/Cargo.toml

@@ -0,0 +1,73 @@
+# 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"
+name = "wasmtime-cache"
+version = "10.0.1"
+authors = ["The Wasmtime Project Developers"]
+description = "Support for automatic module caching with Wasmtime"
+documentation = "https://docs.rs/wasmtime-cache/"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[dependencies.anyhow]
+version = "1.0.22"
+
+[dependencies.base64]
+version = "0.21.0"
+
+[dependencies.bincode]
+version = "1.1.4"
+
+[dependencies.directories-next]
+version = "2.0"
+
+[dependencies.file-per-thread-logger]
+version = "0.2.0"
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.serde]
+version = "1.0.94"
+features = ["derive"]
+
+[dependencies.sha2]
+version = "0.10.2"
+
+[dependencies.toml]
+version = "0.5.5"
+
+[dependencies.zstd]
+version = "0.11.1"
+default-features = false
+
+[dev-dependencies.filetime]
+version = "0.2.7"
+
+[dev-dependencies.once_cell]
+version = "1.12.0"
+
+[dev-dependencies.pretty_env_logger]
+version = "0.4.0"
+
+[dev-dependencies.tempfile]
+version = "3"
+
+[target."cfg(not(target_os = \"windows\"))".dependencies.rustix]
+version = "0.37.13"
+features = ["process"]
+
+[target."cfg(target_os = \"windows\")".dependencies.windows-sys]
+version = "0.48.0"
+features = ["Win32_System_Threading"]

data/ext/cargo-vendor/wasmtime-component-macro-10.0.1/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"aed565eca0f5f7c40571fb06566585a747aa553dd20a114a6909748c95ec6991","src/bindgen.rs":"825b1960bdf2e1ec69853e3aaa6261416ffe7a4252a3e67a16606d65d97e5b5a","src/component.rs":"40dcfb8ced425e633c62cca5ec2d34a7b3c3a9d80d3f7da4dce2b457386e3d88","src/lib.rs":"7950ad824180974edb2b90534e2dc7912df4f0b6d81bbdbb9d5a069347ed1a69","tests/codegen.rs":"df518ef085ad1deab421783a13371d3f6ae566845ff594df82d51e442c124e79","tests/codegen/char.wit":"f9d9fb00749f927aab8bdf4dc205b8d7b48f661c9f70273000a3fdbc76ee0348","tests/codegen/conventions.wit":"a1ab808f814b3a1a627642a5c38a2b8f9f99f7b622a21a14b112a5cf50d1ae9c","tests/codegen/direct-import.wit":"8bcf4dd2c2ce52308dd41c3e9157990ba2ed7d3a554254fc7e2bdcc4d2002469","tests/codegen/empty.wit":"40678dc5b48b6d2018efa7f0a0de404d97a0efbd3a3672e9df5a9b29468ebdf2","tests/codegen/flags.wit":"97615e959e5dac7e5a6e011f03a06def028ff82da8ca7f7cd9ce121211ecc92d","tests/codegen/floats.wit":"2a64a089ac38a53b0c637f919deb2a1353b72d43212e1d857fa29719a35bab6a","tests/codegen/function-new.wit":"570f9eafd15b7500fe27e9719396ac92336c36c945404627cb046b5af0837b8c","tests/codegen/integers.wit":"a5a4207f553df5e4aed7ae85a220fc8c49b192e855ec110ec42f924572a49274","tests/codegen/lists.wit":"7be8e808f929fa5a00e921cd5d7e6d9c38f9ccec38ad12444a878b8e4c71568f","tests/codegen/many-arguments.wit":"e6e5cfff9e57c7060b814a79f35fc742f5e2a5b840e27c37f765e66e71ea3640","tests/codegen/multi-return.wit":"c6abf6c67f4afeddffb5a319bf91f64dcfef1c68b28519664fc768f4f75edee8","tests/codegen/records.wit":"8ec832f7842ffccd5acef3ebd3fa415d3393fe8dfa88b797b9aebfd83976b181","tests/codegen/rename.wit":"8b7466514d2e25c997adcfa95a7e91d159bd5f617b6dd4a3ca0fcca339c4de3f","tests/codegen/share-types.wit":"50c736ade125323ff82ebf3ff4d598acf973e69585ca578cb83f8dd0436e44f3","tests/codegen/simple-functions.wit":"61baad5b98b496e59e899476a4fd26da93e7f1edbda8e17f05e2b5a2c3694958","tests/codegen/simple-lists.wit":"0c03ace53ad859fbeba6ede4fd2834a9853c30c15aa9b01cfcc9a02048d1f291","tests/codegen/simple-wasi.wit":"1b836619582aefdb04899d9e5c22abde2add2b936b215adb86e15a7e8d567533","tests/codegen/small-anonymous.wit":"6df05fdc23b2354e05c986cf18760d399eb0fe3fb0ac8e4c4e6054e525d23fed","tests/codegen/smoke-default.wit":"84792e142417b253c026b5c45cb04e6b9a516f4be9925a5f73958ca4ec861c7c","tests/codegen/smoke-export.wit":"a62d236499078ef8ffd46f13ab6f9dd9ab3990927edb91409e4ff664947105d1","tests/codegen/smoke.wit":"ecb6681008d538d424d27c9b21e60337e9dc86fb541f4ccded7d9066db461020","tests/codegen/strings.wit":"fb743b159d06a523f19f1e704f0055f9dd9ff49ceeba0d2e5554db44df0ba88b","tests/codegen/unions.wit":"fc388d78629e3ddc9bd3bff885e770ef4c94896f56589192ce9780de96e90171","tests/codegen/use-paths.wit":"3efd4012bffb4325af98d654bdc9ba8ae1d65b89fa3ced815d4160e7150215de","tests/codegen/variants.wit":"9d7c77352da7a7ec0322fc0249f607501e94a126a3e3fb698d9605307c086406","tests/codegen/worlds-with-types.wit":"953a367a057f87fe4e92f0b7bf29210cd5b2e7bc85c11a79a45d8e899a93ef0f"},"package":"b8e916103436a6d84faa4c2083e2e98612a323c2cc6147ec419124f67c764c9c"}

data/ext/cargo-vendor/wasmtime-component-macro-10.0.1/Cargo.toml

@@ -0,0 +1,58 @@
+# 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"
+name = "wasmtime-component-macro"
+version = "10.0.1"
+authors = ["The Wasmtime Project Developers"]
+description = "Macros for deriving component interface types from Rust types"
+documentation = "https://docs.rs/wasmtime-component-macro/"
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lib]
+test = false
+doctest = false
+proc-macro = true
+
+[dependencies.anyhow]
+version = "1.0"
+
+[dependencies.proc-macro2]
+version = "1.0"
+
+[dependencies.quote]
+version = "1.0"
+
+[dependencies.syn]
+version = "1.0"
+features = ["extra-traits"]
+
+[dependencies.wasmtime-component-util]
+version = "=10.0.1"
+
+[dependencies.wasmtime-wit-bindgen]
+version = "=10.0.1"
+
+[dependencies.wit-parser]
+version = "0.8.0"
+
+[dev-dependencies.tracing]
+version = "0.1.26"
+
+[features]
+async = []