wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-21.0.1/src/sync_std.rs

@@ -0,0 +1,52 @@
+//! Synchronization primitives for Wasmtime.
+//!
+//! This is a small set of primitives split between std and no_std with "dummy"
+//! implementation on no_std. The no_std implementations live in
+//! `sync_nostd.rs`.
+
+use once_cell::sync::OnceCell;
+use std::ops::{Deref, DerefMut};
+
+/// This type is intended to mirror, and one day be implemented by, the
+/// `std::sync::OnceLock` type. At this time
+/// `std::sync::OnceLock::get_or_try_init` is not stable so for now this is
+/// implemented with the `once_cell` crate instead.
+pub struct OnceLock<T>(OnceCell<T>);
+
+impl<T> OnceLock<T> {
+    #[inline]
+    pub const fn new() -> OnceLock<T> {
+        OnceLock(OnceCell::new())
+    }
+
+    #[inline]
+    pub fn get_or_init(&self, f: impl FnOnce() -> T) -> &T {
+        self.0.get_or_init(f)
+    }
+
+    #[inline]
+    pub fn get_or_try_init<E>(&self, f: impl FnOnce() -> Result<T, E>) -> Result<&T, E> {
+        self.0.get_or_try_init(f)
+    }
+}
+
+/// Small wrapper around `std::sync::RwLock` which undoes poisoning.
+#[derive(Debug, Default)]
+pub struct RwLock<T>(std::sync::RwLock<T>);
+
+impl<T> RwLock<T> {
+    #[inline]
+    pub const fn new(val: T) -> RwLock<T> {
+        RwLock(std::sync::RwLock::new(val))
+    }
+
+    #[inline]
+    pub fn read(&self) -> impl Deref<Target = T> + '_ {
+        self.0.read().unwrap()
+    }
+
+    #[inline]
+    pub fn write(&self) -> impl DerefMut<Target = T> + '_ {
+        self.0.write().unwrap()
+    }
+}

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"287a3527d78385c8b3d832befda2417859aee5eb431e411da1e3656db4867af8","src/lib.rs":"52cfa6e1ce00e0fd54d9c6a3e9e5e6c067953710871db971755db9586e796396"},"package":"6dee8679c974a7f258c03d60d3c747c426ed219945b6d08cbc77fd2eab15b2d1"}

data/ext/cargo-vendor/wasmtime-asm-macros-21.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 = "21.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-asm-macros-21.0.1/src/lib.rs

@@ -0,0 +1,83 @@
+//! This crate defines a macro named `asm_func!` which is suitable for
+//! generating a single `global_asm!`-defined function.
+//!
+//! This macro takes care of platform-specific directives to get the symbol
+//! attributes correct (e.g. ELF symbols get a size and are flagged as a
+//! function) and additionally handles visibility across platforms. All symbols
+//! should be visible to Rust but not visible externally outside of a `*.so`.
+
+#![no_std]
+
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "macos")] {
+        #[macro_export]
+        macro_rules! asm_func {
+            ($name:expr, $body:expr $(, $($args:tt)*)?) => {
+                std::arch::global_asm!(
+                    concat!(
+                        ".p2align 4\n",
+                        ".private_extern _", $name, "\n",
+                        ".global _", $name, "\n",
+                        "_", $name, ":\n",
+                        $body,
+                    ),
+                    $($($args)*)?
+                );
+            };
+        }
+    } else if #[cfg(target_os = "windows")] {
+        #[macro_export]
+        macro_rules! asm_func {
+            ($name:expr, $body:expr $(, $($args:tt)*)?) => {
+                std::arch::global_asm!(
+                    concat!(
+                        ".def ", $name, "\n",
+                        ".scl 2\n",
+                        ".type 32\n",
+                        ".endef\n",
+                        ".global ", $name, "\n",
+                        ".p2align 4\n",
+                        $name, ":\n",
+                        $body
+                    ),
+                    $($($args)*)?
+                );
+            };
+        }
+    } else {
+        // Note that for now this "else" clause just assumes that everything
+        // other than macOS is ELF and has the various directives here for
+        // that.
+        cfg_if::cfg_if! {
+            if #[cfg(target_arch = "arm")] {
+                #[macro_export]
+                macro_rules! elf_func_type_header {
+                    ($name:tt) => (concat!(".type ", $name, ",%function\n"))
+                }
+            } else {
+                #[macro_export]
+                macro_rules! elf_func_type_header {
+                    ($name:tt) => (concat!(".type ", $name, ",@function\n"))
+                }
+            }
+        }
+
+        #[macro_export]
+        macro_rules! asm_func {
+            ($name:expr, $body:expr $(, $($args:tt)*)?) => {
+                std::arch::global_asm!(
+                    concat!(
+                        ".p2align 4\n",
+                        ".hidden ", $name, "\n",
+                        ".global ", $name, "\n",
+                        $crate::elf_func_type_header!($name),
+                        $name, ":\n",
+                        $body,
+                        ".size ", $name, ",.-", $name,
+                    )
+                    $(, $($args)*)?
+                );
+            };
+        }
+    }
+}

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"d809cba3e7a8786eb20628be5f690e3c4ec30e16671e0b1437546626990a5c2c","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"084a263430a3b2291e08a0d3a6df04f8803410f542e1ccadcedc0f8117449929","src/config.rs":"f4930f33187a555ea28850fcc73a6bdf4b5c8c6c906aede10abc1f13f8c2c67f","src/config/tests.rs":"32a819e3d9ec8b3926c3636215df4d6df4c2dd9c42851084dcb1c9f35db48bbf","src/lib.rs":"dd75f57b4da041db9333d0e091d21c9244f88a29d11c92639f7a2171cf465960","src/tests.rs":"a2364cf8d25370343237df25ca8395788d5fb581ebdfd201ce34793c9e87c322","src/worker.rs":"72aaad6684ca934959d3e788356ee433ae981c8afd3d58beef0fb6bd10fa2b3b","src/worker/tests.rs":"c1930c4959d2f5eff950f7ea233631baaa7ceb5d18641f6e3b8d2347ccf2550c","src/worker/tests/system_time_stub.rs":"4fed428563563d59606a1451cd6de14bcb06d55902bb8c1a1dfae28a481ec262","tests/cache_write_default_config.rs":"e0538177c69da417d3855d96aa60f0da1e4ff8048b926727abe0b8c4d36f3785"},"package":"b00103ffaf7ee980f4e750fe272b6ada79d9901659892e457c7ca316b16df9ec"}

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

@@ -0,0 +1,88 @@
+# 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 = "21.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"
+features = ["std"]
+default-features = false
+
+[dependencies.base64]
+version = "0.21.0"
+
+[dependencies.directories-next]
+version = "2.0"
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.postcard]
+version = "1.0.8"
+features = ["alloc"]
+default-features = false
+
+[dependencies.serde]
+version = "1.0.188"
+features = ["alloc"]
+default-features = false
+
+[dependencies.serde_derive]
+version = "1.0.188"
+
+[dependencies.sha2]
+version = "0.10.2"
+
+[dependencies.toml]
+version = "0.8.10"
+
+[dependencies.zstd]
+version = "0.13.0"
+default-features = false
+
+[dev-dependencies.filetime]
+version = "0.2.7"
+
+[dev-dependencies.once_cell]
+version = "1.12.0"
+default-features = false
+
+[dev-dependencies.pretty_env_logger]
+version = "0.5.0"
+
+[dev-dependencies.tempfile]
+version = "3"
+
+[target."cfg(not(target_os = \"windows\"))".dependencies.rustix]
+version = "0.38.31"
+features = ["process"]
+
+[target."cfg(target_os = \"windows\")".dependencies.windows-sys]
+version = "0.52.0"
+features = ["Win32_System_Threading"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/wasmtime-cache-21.0.1/src/lib.rs

@@ -0,0 +1,235 @@
+use base64::Engine;
+use log::{debug, trace, warn};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::{fs, io};
+
+#[macro_use] // for tests
+mod config;
+mod worker;
+
+pub use config::{create_new_config, CacheConfig};
+use worker::Worker;
+
+/// Module level cache entry.
+pub struct ModuleCacheEntry<'config>(Option<ModuleCacheEntryInner<'config>>);
+
+struct ModuleCacheEntryInner<'config> {
+    root_path: PathBuf,
+    cache_config: &'config CacheConfig,
+}
+
+struct Sha256Hasher(Sha256);
+
+impl<'config> ModuleCacheEntry<'config> {
+    /// Create the cache entry.
+    pub fn new<'data>(compiler_name: &str, cache_config: &'config CacheConfig) -> Self {
+        if cache_config.enabled() {
+            Self(Some(ModuleCacheEntryInner::new(
+                compiler_name,
+                cache_config,
+            )))
+        } else {
+            Self(None)
+        }
+    }
+
+    #[cfg(test)]
+    fn from_inner(inner: ModuleCacheEntryInner<'config>) -> Self {
+        Self(Some(inner))
+    }
+
+    /// Gets cached data if state matches, otherwise calls `compute`.
+    ///
+    /// Data is automatically serialized/deserialized with `bincode`.
+    pub fn get_data<T, U, E>(&self, state: T, compute: fn(&T) -> Result<U, E>) -> Result<U, E>
+    where
+        T: Hash,
+        U: Serialize + for<'a> Deserialize<'a>,
+    {
+        self.get_data_raw(
+            &state,
+            compute,
+            |_state, data| postcard::to_allocvec(data).ok(),
+            |_state, data| postcard::from_bytes(&data).ok(),
+        )
+    }
+
+    /// Gets cached data if state matches, otherwise calls `compute`.
+    ///
+    /// If the cache is disabled or no cached data is found then `compute` is
+    /// called to calculate the data. If the data was found in cache it is
+    /// passed to `deserialize`, which if successful will be the returned value.
+    /// When computed the `serialize` function is used to generate the bytes
+    /// from the returned value.
+    pub fn get_data_raw<T, U, E>(
+        &self,
+        state: &T,
+        // NOTE: These are function pointers instead of closures so that they
+        // don't accidentally close over something not accounted in the cache.
+        compute: fn(&T) -> Result<U, E>,
+        serialize: fn(&T, &U) -> Option<Vec<u8>>,
+        deserialize: fn(&T, Vec<u8>) -> Option<U>,
+    ) -> Result<U, E>
+    where
+        T: Hash,
+    {
+        let inner = match &self.0 {
+            Some(inner) => inner,
+            None => return compute(state),
+        };
+
+        let mut hasher = Sha256Hasher(Sha256::new());
+        state.hash(&mut hasher);
+        let hash: [u8; 32] = hasher.0.finalize().into();
+        // standard encoding uses '/' which can't be used for filename
+        let hash = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(&hash);
+
+        if let Some(cached_val) = inner.get_data(&hash) {
+            if let Some(val) = deserialize(state, cached_val) {
+                let mod_cache_path = inner.root_path.join(&hash);
+                inner.cache_config.on_cache_get_async(&mod_cache_path); // call on success
+                return Ok(val);
+            }
+        }
+        let val_to_cache = compute(state)?;
+        if let Some(bytes) = serialize(state, &val_to_cache) {
+            if inner.update_data(&hash, &bytes).is_some() {
+                let mod_cache_path = inner.root_path.join(&hash);
+                inner.cache_config.on_cache_update_async(&mod_cache_path); // call on success
+            }
+        }
+        Ok(val_to_cache)
+    }
+}
+
+impl<'config> ModuleCacheEntryInner<'config> {
+    fn new<'data>(compiler_name: &str, cache_config: &'config CacheConfig) -> Self {
+        // If debug assertions are enabled then assume that we're some sort of
+        // local build. We don't want local builds to stomp over caches between
+        // builds, so just use a separate cache directory based on the mtime of
+        // our executable, which should roughly correlate with "you changed the
+        // source code so you get a different directory".
+        //
+        // Otherwise if this is a release build we use the `GIT_REV` env var
+        // which is either the git rev if installed from git or the crate
+        // version if installed from crates.io.
+        let compiler_dir = if cfg!(debug_assertions) {
+            fn self_mtime() -> Option<String> {
+                let path = std::env::current_exe().ok()?;
+                let metadata = path.metadata().ok()?;
+                let mtime = metadata.modified().ok()?;
+                Some(match mtime.duration_since(std::time::UNIX_EPOCH) {
+                    Ok(dur) => format!("{}", dur.as_millis()),
+                    Err(err) => format!("m{}", err.duration().as_millis()),
+                })
+            }
+            let self_mtime = self_mtime().unwrap_or("no-mtime".to_string());
+            format!(
+                "{comp_name}-{comp_ver}-{comp_mtime}",
+                comp_name = compiler_name,
+                comp_ver = env!("GIT_REV"),
+                comp_mtime = self_mtime,
+            )
+        } else {
+            format!(
+                "{comp_name}-{comp_ver}",
+                comp_name = compiler_name,
+                comp_ver = env!("GIT_REV"),
+            )
+        };
+        let root_path = cache_config.directory().join("modules").join(compiler_dir);
+
+        Self {
+            root_path,
+            cache_config,
+        }
+    }
+
+    fn get_data(&self, hash: &str) -> Option<Vec<u8>> {
+        let mod_cache_path = self.root_path.join(hash);
+        trace!("get_data() for path: {}", mod_cache_path.display());
+        let compressed_cache_bytes = fs::read(&mod_cache_path).ok()?;
+        let cache_bytes = zstd::decode_all(&compressed_cache_bytes[..])
+            .map_err(|err| warn!("Failed to decompress cached code: {}", err))
+            .ok()?;
+        Some(cache_bytes)
+    }
+
+    fn update_data(&self, hash: &str, serialized_data: &[u8]) -> Option<()> {
+        let mod_cache_path = self.root_path.join(hash);
+        trace!("update_data() for path: {}", mod_cache_path.display());
+        let compressed_data = zstd::encode_all(
+            &serialized_data[..],
+            self.cache_config.baseline_compression_level(),
+        )
+        .map_err(|err| warn!("Failed to compress cached code: {}", err))
+        .ok()?;
+
+        // Optimize syscalls: first, try writing to disk. It should succeed in most cases.
+        // Otherwise, try creating the cache directory and retry writing to the file.
+        if fs_write_atomic(&mod_cache_path, "mod", &compressed_data).is_ok() {
+            return Some(());
+        }
+
+        debug!(
+            "Attempting to create the cache directory, because \
+             failed to write cached code to disk, path: {}",
+            mod_cache_path.display(),
+        );
+
+        let cache_dir = mod_cache_path.parent().unwrap();
+        fs::create_dir_all(cache_dir)
+            .map_err(|err| {
+                warn!(
+                    "Failed to create cache directory, path: {}, message: {}",
+                    cache_dir.display(),
+                    err
+                )
+            })
+            .ok()?;
+
+        match fs_write_atomic(&mod_cache_path, "mod", &compressed_data) {
+            Ok(_) => Some(()),
+            Err(err) => {
+                warn!(
+                    "Failed to write file with rename, target path: {}, err: {}",
+                    mod_cache_path.display(),
+                    err
+                );
+                None
+            }
+        }
+    }
+}
+
+impl Hasher for Sha256Hasher {
+    fn finish(&self) -> u64 {
+        panic!("Sha256Hasher doesn't support finish!");
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.0.update(bytes);
+    }
+}
+
+// Assumption: path inside cache directory.
+// Then, we don't have to use sound OS-specific exclusive file access.
+// Note: there's no need to remove temporary file here - cleanup task will do it later.
+fn fs_write_atomic(path: &Path, reason: &str, contents: &[u8]) -> io::Result<()> {
+    let lock_path = path.with_extension(format!("wip-atomic-write-{}", reason));
+    fs::OpenOptions::new()
+        .create_new(true) // atomic file creation (assumption: no one will open it without this flag)
+        .write(true)
+        .open(&lock_path)
+        .and_then(|mut file| file.write_all(contents))
+        // file should go out of scope and be closed at this point
+        .and_then(|()| fs::rename(&lock_path, &path)) // atomic file rename
+}
+
+#[cfg(test)]
+mod tests;

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"d9bc988d2483f5b845f7f2b89c00faad6e8dff9a84a07940742ccb5f00719785","build.rs":"0067e626dfcf105d55adda251ed37b72dd4797c764dc8bf08511d847fc7a4a7a","src/bindgen.rs":"228c680dab151dd1ca92be309008e35baf5fc666530f9ce52ff67deaf9a0bcbc","src/component.rs":"321ab643492411c5b483757ffe009677251ecd99556fe7cf6198e620d097d00a","src/lib.rs":"7950ad824180974edb2b90534e2dc7912df4f0b6d81bbdbb9d5a069347ed1a69","tests/codegen.rs":"6c25055949651aa83d0507c4a26db204cce1ad6ab700f24372bd62b5cfeeaccf","tests/codegen/char.wit":"3a731ee7325e54e8494fa15b96ec8df50b7ad07f34e741b5b55a798cc6858d38","tests/codegen/conventions.wit":"b78144acdea1168381756ab1a3b7bdb2b23be5de4f3db78139c04893b85d373e","tests/codegen/dead-code.wit":"b294e7f6126308796f5ebad94f283dee2c28acb7ecbf1d83f462cdebad487243","tests/codegen/direct-import.wit":"a6c312877b15c2fcdd34db9f52f77d198eb8a6b99f31ba4ec36f5b2ec66effdd","tests/codegen/empty.wit":"7874837ba306e8bffafc5b404f8ae3b0edff93f8ec89a16a251606d055fc1ef8","tests/codegen/flags.wit":"43f9af51c6e444e18e0da556fb7116e70de7710d1880e2f06af704ba32bab92d","tests/codegen/floats.wit":"dc6916ee5ef27f6d00bdeef32a363f85eb078cd4518973175f037948987d128d","tests/codegen/function-new.wit":"7d3d4383afc395321c4a0d780a293c1940cfcf58098568eecaf42364c9c83b3e","tests/codegen/integers.wit":"2a75648502290cc9e0264f71a0c0175cd1ba0756b1cd6e840080ad7327469eeb","tests/codegen/lists.wit":"900a0d3eb8176c4703690c9d42a99e55893815541825333e8e606d9fde33e712","tests/codegen/many-arguments.wit":"800948d14043ecccef1677a9e48b86fedcf9e368c851ee539ea93e575e9a72e3","tests/codegen/multi-return.wit":"9bff3e4bc93d8169a951443f02692cf0c3d2583737ac1156f7bb41840973ba5e","tests/codegen/multiversion/deps/v1/root.wit":"3f9b6ac5dfbd1f8ac8ec0d1e8ffb1f6bd34d42f546d55293868ac3f54ee870dd","tests/codegen/multiversion/deps/v2/root.wit":"e0c635ca0dd8f73eec3301332157c1a067b1533b214b3c076316e19eaec38cae","tests/codegen/multiversion/root.wit":"748f057ace46d2fc035d040993a2d0aeb0cd202f399e30c9b17b253e5672d1ec","tests/codegen/records.wit":"e8aaac38df43c81b1663ae3cd52cbe7ee74c24d18d60ea0daafaed5fd15749c2","tests/codegen/rename.wit":"d063db707f0914d8570cde2e5d4e075da366e4edb314d7971643ffd4787ee739","tests/codegen/resources-export.wit":"dddd289af8dfeb0c409caeacfc8b48f16d3ba9abf8ac6b7de6454b45d2aaeaa3","tests/codegen/resources-import.wit":"5c030b21fd9a02b81aed35d2a3ee5b14bd64c0f47866e2584c8058f5ce16833d","tests/codegen/share-types.wit":"97f8265c88aa002a8245f8cc86cee9fa5feae3742dae909ceae226f9d06ef77a","tests/codegen/simple-functions.wit":"7416e4676e0806f3967683671ace67078c53b2baab2ab9e132a823494ea8d38e","tests/codegen/simple-lists.wit":"32e5f8c12868009cc4d46695b3cbd1bef79ade90c30210d4327bcac17aba7818","tests/codegen/simple-wasi.wit":"176801368e001b1e2dca83f2be82804f316546c800ff988644a67b1b4fd47f04","tests/codegen/small-anonymous.wit":"9ee8953f815595f653a39fe32af7d71e51bb3ad54615a333799d38ffa6a0a8ef","tests/codegen/smoke-default.wit":"f361239858b59b07d6a1cff5a5fd618360d6a603111bb2f5fffe80e4a2767cb2","tests/codegen/smoke-export.wit":"09531839d5e90c8827d94cef4f646d1232377b4086aba7200ac387af7224d87f","tests/codegen/smoke.wit":"a52173e9490a73c75132186e0657284ed1d2f6c33dd14b330e851ec880869341","tests/codegen/strings.wit":"7e1465b7730a56bc7ba8f6a3fead29e4558d3ad58f38da94da246cb8fbe07996","tests/codegen/unversioned-foo.wit":"185a83194bddd6234319016eff65046445809e1ef45af50e19001fe4c640bdb3","tests/codegen/use-paths.wit":"523723be1767525497422afe1f9a4da4f0a3fb07cfc83e7196b8c109d0e4f153","tests/codegen/variants.wit":"cc3071a696624bdb5713c2fb6dc9bc60073abbb191874595e656f2cc774ae7e1","tests/codegen/wat.wit":"dc094243945e979572c60bc3689cc9916c1022d2a3fbba3a083095fa3017fdab","tests/codegen/worlds-with-types.wit":"2eea2fadc327ee6a77b424373f48fe3ac937af6ee21cc3b1f6ff41e81b23200f","tests/codegen_no_std.rs":"aa99fe0097352f49d7f27b63ef124d927e37f13ae5d73b4808644bd9ed008dca"},"package":"32cae30035f1cf97dcc6657c979cf39f99ce6be93583675eddf4aeaa5548509c"}

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

@@ -0,0 +1,79 @@
+# 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 = "21.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 = "2.0.25"
+features = ["extra-traits"]
+
+[dependencies.wasmtime-component-util]
+version = "=21.0.1"
+
+[dependencies.wasmtime-wit-bindgen]
+version = "=21.0.1"
+
+[dependencies.wit-parser]
+version = "0.207.0"
+
+[dev-dependencies.serde]
+version = "1.0.188"
+features = [
+    "alloc",
+    "derive",
+]
+default-features = false
+
+[dev-dependencies.serde_json]
+version = "1.0.80"
+
+[dev-dependencies.tracing]
+version = "0.1.26"
+
+[features]
+async = []
+std = ["wasmtime-wit-bindgen/std"]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"