wasmtime 10.0.0 → 11.0.0

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"3d70251cc9e2c74906448e2f6af5d3c9fc85daa22e28b006958de39f66aac0de","src/lib.rs":"1cb36602e92d2984e218fd6c6455308018afd155754fb3801a12c06613a757ce"},"package":"63b6f7d8cf9596651289a7d5814fe30100ce3bfb7bbfcb1ac0808b2d66a4d574"}

data/ext/cargo-vendor/wasmtime-asm-macros-11.0.0/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 = "11.0.0"
+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-11.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"1074e8001add5709b805140492ffe82b1785592f5634062372318a97bbaa5b9d","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":"6c786610bc63d8421fe2cd247b6d92c40631f48bf07a0690c419d456ea35c818"}

data/ext/cargo-vendor/wasmtime-cache-11.0.0/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 = "11.0.0"
+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-11.0.0/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"735db4969cd588a408816562ab2ef06202bc5eeb8b73df7cf3d5852e95e7c077","src/bindgen.rs":"a16d15cb99928848a4591fc7e3bbd0de865f910d900e9bc6c3fab8ac30c3ea5a","src/component.rs":"671e2d37ec439e988cbc609f858b675b7890e3a0906706608e17ce68397ee668","src/lib.rs":"7950ad824180974edb2b90534e2dc7912df4f0b6d81bbdbb9d5a069347ed1a69","tests/codegen.rs":"9bcdb75248677979028dee518bd4840c5478885febfb23f146d38180a11567ec","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":"3f24d8ac8f93f6f76601d8be9843ab11c419b4a8767d2e154f422e36062eccf9"}

data/ext/cargo-vendor/wasmtime-component-macro-11.0.0/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 = "11.0.0"
+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 = "=11.0.0"
+
+[dependencies.wasmtime-wit-bindgen]
+version = "=11.0.0"
+
+[dependencies.wit-parser]
+version = "0.8.0"
+
+[dev-dependencies.tracing]
+version = "0.1.26"
+
+[features]
+async = []

data/ext/cargo-vendor/wasmtime-component-macro-11.0.0/src/bindgen.rs

@@ -0,0 +1,348 @@
+use proc_macro2::{Span, TokenStream};
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use syn::parse::{Error, Parse, ParseStream, Result};
+use syn::punctuated::Punctuated;
+use syn::{braced, token, Ident, Token};
+use wasmtime_wit_bindgen::{Opts, Ownership, TrappableError};
+use wit_parser::{PackageId, Resolve, UnresolvedPackage, WorldId};
+
+pub struct Config {
+    opts: Opts,
+    resolve: Resolve,
+    world: WorldId,
+    files: Vec<PathBuf>,
+}
+
+pub fn expand(input: &Config) -> Result<TokenStream> {
+    if !cfg!(feature = "async") && input.opts.async_ {
+        return Err(Error::new(
+            Span::call_site(),
+            "cannot enable async bindings unless `async` crate feature is active",
+        ));
+    }
+
+    let src = input.opts.generate(&input.resolve, input.world);
+    let mut contents = src.parse::<TokenStream>().unwrap();
+
+    // Include a dummy `include_str!` for any files we read so rustc knows that
+    // we depend on the contents of those files.
+    for file in input.files.iter() {
+        contents.extend(
+            format!("const _: &str = include_str!(r#\"{}\"#);\n", file.display())
+                .parse::<TokenStream>()
+                .unwrap(),
+        );
+    }
+
+    Ok(contents)
+}
+
+impl Parse for Config {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let call_site = Span::call_site();
+        let mut opts = Opts::default();
+        let mut world = None;
+        let mut inline = None;
+        let mut path = None;
+
+        if input.peek(token::Brace) {
+            let content;
+            syn::braced!(content in input);
+            let fields = Punctuated::<Opt, Token![,]>::parse_terminated(&content)?;
+            for field in fields.into_pairs() {
+                match field.into_value() {
+                    Opt::Path(s) => {
+                        if path.is_some() {
+                            return Err(Error::new(s.span(), "cannot specify second path"));
+                        }
+                        path = Some(s.value());
+                    }
+                    Opt::World(s) => {
+                        if world.is_some() {
+                            return Err(Error::new(s.span(), "cannot specify second world"));
+                        }
+                        world = Some(s.value());
+                    }
+                    Opt::Inline(s) => {
+                        if inline.is_some() {
+                            return Err(Error::new(s.span(), "cannot specify second source"));
+                        }
+                        inline = Some(s.value());
+                    }
+                    Opt::Tracing(val) => opts.tracing = val,
+                    Opt::Async(val) => opts.async_ = val,
+                    Opt::TrappableErrorType(val) => opts.trappable_error_type = val,
+                    Opt::Ownership(val) => opts.ownership = val,
+                    Opt::Interfaces(s) => {
+                        if inline.is_some() {
+                            return Err(Error::new(s.span(), "cannot specify a second source"));
+                        }
+                        inline = Some(format!(
+                            "
+                                package wasmtime:component-macro-synthesized
+
+                                world interfaces {{
+                                    {}
+                                }}
+                            ",
+                            s.value()
+                        ));
+
+                        if world.is_some() {
+                            return Err(Error::new(
+                                s.span(),
+                                "cannot specify a world with `interfaces`",
+                            ));
+                        }
+                        world = Some("interfaces".to_string());
+
+                        opts.only_interfaces = true;
+                    }
+                    Opt::With(val) => opts.with.extend(val),
+                }
+            }
+        } else {
+            world = input.parse::<Option<syn::LitStr>>()?.map(|s| s.value());
+            if input.parse::<Option<syn::token::In>>()?.is_some() {
+                path = Some(input.parse::<syn::LitStr>()?.value());
+            }
+        }
+        let (resolve, pkg, files) = parse_source(&path, &inline)
+            .map_err(|err| Error::new(call_site, format!("{err:?}")))?;
+
+        let world = resolve
+            .select_world(pkg, world.as_deref())
+            .map_err(|e| Error::new(call_site, format!("{e:?}")))?;
+        Ok(Config {
+            opts,
+            resolve,
+            world,
+            files,
+        })
+    }
+}
+
+fn parse_source(
+    path: &Option<String>,
+    inline: &Option<String>,
+) -> anyhow::Result<(Resolve, PackageId, Vec<PathBuf>)> {
+    let mut resolve = Resolve::default();
+    let mut files = Vec::new();
+    let root = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
+
+    let mut parse = |resolve: &mut Resolve, path: &Path| -> anyhow::Result<_> {
+        if path.is_dir() {
+            let (pkg, sources) = resolve.push_dir(path)?;
+            files = sources;
+            Ok(pkg)
+        } else {
+            let pkg = UnresolvedPackage::parse_file(path)?;
+            files.extend(pkg.source_files().map(|s| s.to_owned()));
+            resolve.push(pkg)
+        }
+    };
+
+    let path_pkg = if let Some(path) = path {
+        Some(parse(&mut resolve, &root.join(&path))?)
+    } else {
+        None
+    };
+
+    let inline_pkg = if let Some(inline) = inline {
+        Some(resolve.push(UnresolvedPackage::parse("macro-input".as_ref(), &inline)?)?)
+    } else {
+        None
+    };
+
+    let pkg = inline_pkg
+        .or(path_pkg)
+        .map_or_else(|| parse(&mut resolve, &root.join("wit")), Ok)?;
+
+    Ok((resolve, pkg, files))
+}
+
+mod kw {
+    syn::custom_keyword!(inline);
+    syn::custom_keyword!(path);
+    syn::custom_keyword!(tracing);
+    syn::custom_keyword!(trappable_error_type);
+    syn::custom_keyword!(world);
+    syn::custom_keyword!(ownership);
+    syn::custom_keyword!(interfaces);
+    syn::custom_keyword!(with);
+}
+
+enum Opt {
+    World(syn::LitStr),
+    Path(syn::LitStr),
+    Inline(syn::LitStr),
+    Tracing(bool),
+    Async(bool),
+    TrappableErrorType(Vec<TrappableError>),
+    Ownership(Ownership),
+    Interfaces(syn::LitStr),
+    With(HashMap<String, String>),
+}
+
+impl Parse for Opt {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let l = input.lookahead1();
+        if l.peek(kw::path) {
+            input.parse::<kw::path>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::Path(input.parse()?))
+        } else if l.peek(kw::inline) {
+            input.parse::<kw::inline>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::Inline(input.parse()?))
+        } else if l.peek(kw::world) {
+            input.parse::<kw::world>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::World(input.parse()?))
+        } else if l.peek(kw::tracing) {
+            input.parse::<kw::tracing>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::Tracing(input.parse::<syn::LitBool>()?.value))
+        } else if l.peek(Token![async]) {
+            input.parse::<Token![async]>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::Async(input.parse::<syn::LitBool>()?.value))
+        } else if l.peek(kw::ownership) {
+            input.parse::<kw::ownership>()?;
+            input.parse::<Token![:]>()?;
+            let ownership = input.parse::<syn::Ident>()?;
+            Ok(Opt::Ownership(match ownership.to_string().as_str() {
+                "Owning" => Ownership::Owning,
+                "Borrowing" => Ownership::Borrowing {
+                    duplicate_if_necessary: {
+                        let contents;
+                        braced!(contents in input);
+                        let field = contents.parse::<syn::Ident>()?;
+                        match field.to_string().as_str() {
+                            "duplicate_if_necessary" => {
+                                contents.parse::<Token![:]>()?;
+                                contents.parse::<syn::LitBool>()?.value
+                            }
+                            name => {
+                                return Err(Error::new(
+                                    field.span(),
+                                    format!(
+                                        "unrecognized `Ownership::Borrowing` field: `{name}`; \
+                                         expected `duplicate_if_necessary`"
+                                    ),
+                                ));
+                            }
+                        }
+                    },
+                },
+                name => {
+                    return Err(Error::new(
+                        ownership.span(),
+                        format!(
+                            "unrecognized ownership: `{name}`; \
+                             expected `Owning` or `Borrowing`"
+                        ),
+                    ));
+                }
+            }))
+        } else if l.peek(kw::trappable_error_type) {
+            input.parse::<kw::trappable_error_type>()?;
+            input.parse::<Token![:]>()?;
+            let contents;
+            let _lbrace = braced!(contents in input);
+            let fields: Punctuated<(String, String, String), Token![,]> =
+                contents.parse_terminated(trappable_error_field_parse)?;
+            Ok(Opt::TrappableErrorType(
+                fields
+                    .into_iter()
+                    .map(|(wit_owner, wit_name, rust_name)| TrappableError {
+                        wit_owner: Some(wit_owner),
+                        wit_name,
+                        rust_name,
+                    })
+                    .collect(),
+            ))
+        } else if l.peek(kw::interfaces) {
+            input.parse::<kw::interfaces>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::Interfaces(input.parse::<syn::LitStr>()?))
+        } else if l.peek(kw::with) {
+            input.parse::<kw::with>()?;
+            input.parse::<Token![:]>()?;
+            let contents;
+            let _lbrace = braced!(contents in input);
+            let fields: Punctuated<(String, String), Token![,]> =
+                contents.parse_terminated(with_field_parse)?;
+            Ok(Opt::With(HashMap::from_iter(fields.into_iter())))
+        } else {
+            Err(l.error())
+        }
+    }
+}
+
+fn trappable_error_field_parse(input: ParseStream<'_>) -> Result<(String, String, String)> {
+    // Accept a Rust identifier or a string literal. This is required
+    // because not all wit identifiers are Rust identifiers, so we can
+    // smuggle the invalid ones inside quotes.
+    fn ident_or_str(input: ParseStream<'_>) -> Result<String> {
+        let l = input.lookahead1();
+        if l.peek(syn::LitStr) {
+            Ok(input.parse::<syn::LitStr>()?.value())
+        } else if l.peek(syn::Ident) {
+            Ok(input.parse::<syn::Ident>()?.to_string())
+        } else {
+            Err(l.error())
+        }
+    }
+
+    let interface = ident_or_str(input)?;
+    input.parse::<Token![::]>()?;
+    let type_ = ident_or_str(input)?;
+    input.parse::<Token![:]>()?;
+    let rust_type = input.parse::<Ident>()?.to_string();
+    Ok((interface, type_, rust_type))
+}
+
+fn with_field_parse(input: ParseStream<'_>) -> Result<(String, String)> {
+    let interface = input.parse::<syn::LitStr>()?.value();
+    input.parse::<Token![:]>()?;
+    let start = input.span();
+    let path = input.parse::<syn::Path>()?;
+
+    // It's not possible for the segments of a path to be empty
+    let span = start
+        .join(path.segments.last().unwrap().ident.span())
+        .unwrap_or(start);
+
+    let mut buf = String::new();
+    let append = |buf: &mut String, segment: syn::PathSegment| -> Result<()> {
+        if segment.arguments != syn::PathArguments::None {
+            return Err(Error::new(
+                span,
+                "Module path must not contain angles or parens",
+            ));
+        }
+
+        buf.push_str(&segment.ident.to_string());
+
+        Ok(())
+    };
+
+    if path.leading_colon.is_some() {
+        buf.push_str("::");
+    }
+
+    let mut segments = path.segments.into_iter();
+
+    if let Some(segment) = segments.next() {
+        append(&mut buf, segment)?;
+    }
+
+    for segment in segments {
+        buf.push_str("::");
+        append(&mut buf, segment)?;
+    }
+
+    Ok((interface, buf))
+}