wasmtime 17.0.1 → 18.0.3

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"73eafbbc6e67726f6ee89c588486610c2f19f807ecb2317d1509eca2958a6cee","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","build.rs":"084a263430a3b2291e08a0d3a6df04f8803410f542e1ccadcedc0f8117449929","src/config.rs":"17d84541dfc27bdc7ac9c1d1b3abc5dd32f7ebe16fa401983e7095a293dd422c","src/config/tests.rs":"68489ca054ee6dbe272c5c03d4d743292658cc1fe5f5a537af7c314d982238e6","src/lib.rs":"8797e8cad90bb611497703c693263cece93141b23ce125d7f3331f581984f6eb","src/tests.rs":"f2e96fca0bf4007514b406c1a9c43aef3157506076348c2ca8150dfa23ad6717","src/worker.rs":"c49322c54801848eb88301fbb7a02d5933e2b7fce8cfd5170afacea8eef046cf","src/worker/tests.rs":"e8dd49eb98a685ce8301b6e4abde022cb6951197091b5b0879ecdb025abecc91","src/worker/tests/system_time_stub.rs":"4fed428563563d59606a1451cd6de14bcb06d55902bb8c1a1dfae28a481ec262","tests/cache_write_default_config.rs":"e0538177c69da417d3855d96aa60f0da1e4ff8048b926727abe0b8c4d36f3785"},"package":"3249204a71d728d53fb3eea18afd0473f87e520445707a4d567ac4da0bb3eb5d"}

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

@@ -0,0 +1,81 @@
+# 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 = "18.0.3"
+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.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.serde]
+version = "1.0.188"
+
+[dependencies.serde_derive]
+version = "1.0.188"
+
+[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.5.0"
+
+[dev-dependencies.tempfile]
+version = "3"
+
+[target."cfg(not(target_os = \"windows\"))".dependencies.rustix]
+version = "0.38.21"
+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-component-macro-18.0.3/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"66bd2b9e374a4093f6e9430db8c91c07bd3bb2f177ef934aecddf6e66bf1a8bf","build.rs":"0067e626dfcf105d55adda251ed37b72dd4797c764dc8bf08511d847fc7a4a7a","src/bindgen.rs":"7aaea29f4225e011029c10ff79b2c290dc83862452b32660dd7f984f955b7f6e","src/component.rs":"853bc7e4b1d3a273d8388b468d47867a2a972a4bb84b135b1ff5b86c8800f7fc","src/lib.rs":"7950ad824180974edb2b90534e2dc7912df4f0b6d81bbdbb9d5a069347ed1a69","tests/codegen.rs":"d367230e3d25976c4bf2c8a05f71f0c9cd980dd2ee7a9b9719b82c3bbd181f92","tests/codegen/char.wit":"3a731ee7325e54e8494fa15b96ec8df50b7ad07f34e741b5b55a798cc6858d38","tests/codegen/conventions.wit":"b78144acdea1168381756ab1a3b7bdb2b23be5de4f3db78139c04893b85d373e","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/use-paths.wit":"523723be1767525497422afe1f9a4da4f0a3fb07cfc83e7196b8c109d0e4f153","tests/codegen/variants.wit":"cc3071a696624bdb5713c2fb6dc9bc60073abbb191874595e656f2cc774ae7e1","tests/codegen/wat.wit":"dc094243945e979572c60bc3689cc9916c1022d2a3fbba3a083095fa3017fdab","tests/codegen/worlds-with-types.wit":"2eea2fadc327ee6a77b424373f48fe3ac937af6ee21cc3b1f6ff41e81b23200f"},"package":"7d3786c0531565ec6c9852c0e46299f06cb6e4b58d36e30f3c234cfa69bde376"}

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

@@ -0,0 +1,67 @@
+# 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 = "18.0.3"
+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 = "=18.0.3"
+
+[dependencies.wasmtime-wit-bindgen]
+version = "=18.0.3"
+
+[dependencies.wit-parser]
+version = "0.13.1"
+
+[dev-dependencies.tracing]
+version = "0.1.26"
+
+[features]
+async = []
+
+[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-component-macro-18.0.3/build.rs

@@ -0,0 +1,5 @@
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+    println!("cargo:rustc-env=DEBUG_OUTPUT_DIR={out_dir}");
+}

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

@@ -0,0 +1,396 @@
+use proc_macro2::{Span, TokenStream};
+use quote::ToTokens;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use syn::parse::{Error, Parse, ParseStream, Result};
+use syn::punctuated::Punctuated;
+use syn::{braced, token, Token};
+use wasmtime_wit_bindgen::{AsyncConfig, 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_.maybe_async() {
+        return Err(Error::new(
+            Span::call_site(),
+            "cannot enable async bindings unless `async` crate feature is active",
+        ));
+    }
+
+    let mut src = input.opts.generate(&input.resolve, input.world);
+
+    // If a magical `WASMTIME_DEBUG_BINDGEN` environment variable is set then
+    // place a formatted version of the expanded code into a file. This file
+    // will then show up in rustc error messages for any codegen issues and can
+    // be inspected manually.
+    if std::env::var("WASMTIME_DEBUG_BINDGEN").is_ok() {
+        static INVOCATION: AtomicUsize = AtomicUsize::new(0);
+        let root = Path::new(env!("DEBUG_OUTPUT_DIR"));
+        let world_name = &input.resolve.worlds[input.world].name;
+        let n = INVOCATION.fetch_add(1, Relaxed);
+        let path = root.join(format!("{world_name}{n}.rs"));
+
+        std::fs::write(&path, &src).unwrap();
+
+        // optimistically format the code but don't require success
+        drop(
+            std::process::Command::new("rustfmt")
+                .arg(&path)
+                .arg("--edition=2021")
+                .output(),
+        );
+
+        src = format!("include!({path:?});");
+    }
+    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;
+        let mut async_configured = false;
+
+        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, span) => {
+                        if async_configured {
+                            return Err(Error::new(span, "cannot specify second async config"));
+                        }
+                        async_configured = true;
+                        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);
+    syn::custom_keyword!(except_imports);
+    syn::custom_keyword!(only_imports);
+}
+
+enum Opt {
+    World(syn::LitStr),
+    Path(syn::LitStr),
+    Inline(syn::LitStr),
+    Tracing(bool),
+    Async(AsyncConfig, Span),
+    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]) {
+            let span = input.parse::<Token![async]>()?.span;
+            input.parse::<Token![:]>()?;
+            if input.peek(syn::LitBool) {
+                match input.parse::<syn::LitBool>()?.value {
+                    true => Ok(Opt::Async(AsyncConfig::All, span)),
+                    false => Ok(Opt::Async(AsyncConfig::None, span)),
+                }
+            } else {
+                let contents;
+                syn::braced!(contents in input);
+
+                let l = contents.lookahead1();
+                let ctor: fn(HashSet<String>) -> AsyncConfig = if l.peek(kw::except_imports) {
+                    contents.parse::<kw::except_imports>()?;
+                    contents.parse::<Token![:]>()?;
+                    AsyncConfig::AllExceptImports
+                } else if l.peek(kw::only_imports) {
+                    contents.parse::<kw::only_imports>()?;
+                    contents.parse::<Token![:]>()?;
+                    AsyncConfig::OnlyImports
+                } else {
+                    return Err(l.error());
+                };
+
+                let list;
+                syn::bracketed!(list in contents);
+                let fields: Punctuated<syn::LitStr, Token![,]> =
+                    list.parse_terminated(Parse::parse, Token![,])?;
+
+                if contents.peek(Token![,]) {
+                    contents.parse::<Token![,]>()?;
+                }
+                Ok(Opt::Async(
+                    ctor(fields.iter().map(|s| s.value()).collect()),
+                    span,
+                ))
+            }
+        } 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<_, Token![,]> =
+                contents.parse_terminated(trappable_error_field_parse, Token![,])?;
+            Ok(Opt::TrappableErrorType(Vec::from_iter(fields)))
+        } 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, Token![,])?;
+            Ok(Opt::With(HashMap::from_iter(fields)))
+        } else {
+            Err(l.error())
+        }
+    }
+}
+
+fn trappable_error_field_parse(input: ParseStream<'_>) -> Result<TrappableError> {
+    let wit_path = input.parse::<syn::LitStr>()?.value();
+    input.parse::<Token![=>]>()?;
+    let rust_type_name = input.parse::<syn::Path>()?.to_token_stream().to_string();
+    Ok(TrappableError {
+        wit_path,
+        rust_type_name,
+    })
+}
+
+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))
+}

data/ext/cargo-vendor/wasmtime-component-macro-18.0.3/tests/codegen/wat.wit

@@ -0,0 +1,10 @@
+package same:name;
+
+interface this-name-is-duplicated {
+  resource this-name-is-duplicated {
+  }
+}
+
+world example {
+  export this-name-is-duplicated;
+}

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"b8d81edb41a35dd09ef132d77af430c48513c68ac9a8f3562a6b35d2dab71400","src/lib.rs":"5cd3c8a9e839b14ee09a1409c719d688bb0809f535bc53bbfcfd45e8202178a0"},"package":"81eae2ec98027ee0b3950da83bc320120a23087ac4d39b3d59201cb5ebf52777"}

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

@@ -0,0 +1,25 @@
+# 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-util"
+version = "18.0.3"
+authors = ["The Wasmtime Project Developers"]
+description = "Utility types and functions to support the component model in Wasmtime"
+documentation = "https://docs.rs/wasmtime-component-util/"
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"a0c1e7db78a8b6ae562359529c16f371b37cede57640b9cc499137fa206396d7","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","SECURITY.md":"88ef39090879a80611c6ebfbefc1a71950f0e0f15258e953f329fba9afa56db6","src/builder.rs":"3ed8462f100664aad10c56b3d9dff911a8bebd95248df48a6c812d84615024c6","src/compiler.rs":"db772dab0e82bfe89af4bc384be450b029677c915ebc9ac70d5de43366609e3a","src/compiler/component.rs":"48be501c7dc5355bc333e6299f1d10d169e47489c4b205cfcadd722d57f421a4","src/debug.rs":"54832e39cd06a875e029792e8d66a16f50cc310a79df3171e747c2bac1ea10d2","src/debug/gc.rs":"308e96a7581799e4535df0b2e80da8022f3d5fd1fff585d82ad3281f11a28e15","src/debug/transform/address_transform.rs":"42e9bcf972b9fb9319bd381fd4d09ea71c6051f15e440ab0347f6f00606b3a3e","src/debug/transform/attr.rs":"e515ba1bdda8e4f50af0299b2d0e5630527811f80b79eaf453e6d6802e1fdb13","src/debug/transform/expression.rs":"874c3693246ee1aca7d7cf3b961c8c3e96485ca676be0853344c095f4ccd620e","src/debug/transform/line_program.rs":"d2ee371500cf69faf60720ad626495e438a5676689a1e90ee02bb929d5cfaa85","src/debug/transform/mod.rs":"8242b0c6487514c7530e0faa120f7f7376e23fdcedf82baecd5fd559abb6fadb","src/debug/transform/range_info_builder.rs":"75609512209d1017a4ab4ec3818f8f1ff8333b73e884836e40f5ab7ab31cd77d","src/debug/transform/refs.rs":"f50c58de74ef59f69b5df24b8e62da7ee6ea1ab09c536eae4eea3a0c9744dfd9","src/debug/transform/simulate.rs":"ca1f22d5ed666471d8ba7dea28c56cb790027349be15f3f2a31ca888705c7c54","src/debug/transform/unit.rs":"c5387154ab8ff62178887c71c418e4e4ae3c8a0af8a675e73f09735c169dd464","src/debug/transform/utils.rs":"e44e012abec828b3188fe3e973cf9a642abfa5fa4778516351c43483d86e45a3","src/debug/write_debuginfo.rs":"61f13d525be829be85331d523c8feeddca9efb9919dae81a06d18e997f2234fe","src/func_environ.rs":"63e4fbc5c2936dc6a175c1f792f4dc7110ea49c1bfb2ce3f505ea7bad86209ab","src/lib.rs":"5015b3b48182c597368b94dfad6885405ced8d2f61abb2a571bf04d5995436b5"},"package":"595abdb067acdc812ab0f21d8d46d5aa4022392aa7c3e0632c20bff9ec49ffb4"}