wasmtime 24.0.0 → 25.0.0

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

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"2cb246d2ff7e0d7183cb801b858465393b68373e8d7678151dda2dc1bfe76bec","build.rs":"0067e626dfcf105d55adda251ed37b72dd4797c764dc8bf08511d847fc7a4a7a","src/bindgen.rs":"de406b766d0a3375235f6094da223e0efa0a3d103e60fd925be9b9c9d5998ae3","src/component.rs":"04a3b4f8c35ecc787600089514813f9e8dfc9edeef5562d09d4c32788daa0080","src/lib.rs":"7950ad824180974edb2b90534e2dc7912df4f0b6d81bbdbb9d5a069347ed1a69","tests/codegen.rs":"0e221e3621847ee1b97103bfad0a79b6aced72f070273447fe5dc13dd9570d78","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","tests/expanded.rs":"894577c83789ef763b8ca0fcedd6705bd1b5abdc3abfa4c217bab03cdcb7b7a5","tests/expanded/char.rs":"b062aa6f1c6c45593cb91e701116fa9543beddfeb9110560257c3d9d341d9b62","tests/expanded/char_async.rs":"c3bb1f662f2bdabd4d8714e42ed70b8be5847292935a7e5681a9d7b0f8155350","tests/expanded/conventions.rs":"fe9ee8e1528c7cb90f9f95e6d84e8e527f84fd10eb952c4a64b6b15bd78af25f","tests/expanded/conventions_async.rs":"b04ce63b59a15669756cb35cf655e2c7bb73840fb7790ff6c7f13fc40673e0f5","tests/expanded/dead-code.rs":"76f8642bd6fdf783f3bce13b7893389ddcdb707d4c7b05dd69187433ec094546","tests/expanded/dead-code_async.rs":"2227ce03f51f8d4b594a405811f2a511dc8bd1a247491f4ea0cd00a443383ffa","tests/expanded/direct-import.rs":"eff7b31762c572e0edba697dbf584aeee76556a0f4ecaf7fa6382a007688f341","tests/expanded/direct-import_async.rs":"a152a0c42c6e19e4e7c32284289d3a1698eb395ecf88ee929559eb99c37a5fb0","tests/expanded/empty.rs":"221dabb45fb68917a14e9361b3ba37234c3ac179fbf5c919b864e4a99d989276","tests/expanded/empty_async.rs":"d5f80aaa44f6d137f548de86f4d0a9e2be97f8ce22cec92117738d56c4898e4d","tests/expanded/flags.rs":"e9120b4fbc80978b92f81136bdf74c66a3fed614fd8f6eb8af50287a8c524954","tests/expanded/flags_async.rs":"78be35deaddd482fe6ca3c0e2e00fc32a0477e9ceab27a2e374d0af2fe3b4ee0","tests/expanded/floats.rs":"ee252accfe64cd22bb41741cdca75b933f505b0e2e0f2d400f047069f660006a","tests/expanded/floats_async.rs":"c9d7a7577d4a56c522f7287047c3e615b28c74686f43c974f9657ccd9f87c2a6","tests/expanded/function-new.rs":"4881ead8abe01e1a2639ac8f476b7f0f1a865befff591e469340843f5b892bf5","tests/expanded/function-new_async.rs":"803feab89e32e5f3d6124acf252e412417e5d86683c9c392fa80b30d1cd7f2bb","tests/expanded/integers.rs":"7946e0f986d6af0cd972e99f7cc684f4b1abaa5bed312cc9ec7f1d975b075abb","tests/expanded/integers_async.rs":"4e1431628b1ffbd3d6aab1e8a82d1ff587a213f3cb166ad404acf5b5f58ca45f","tests/expanded/lists.rs":"a1ffc1120ab0e8d1d9aa2494fd695c538fb76a1ef0da9622f55efd5310487a8e","tests/expanded/lists_async.rs":"9e931fa7dce2c48f657d4b1079c412cf8af3b507a2490ca63b79160d29531b9e","tests/expanded/many-arguments.rs":"9253a382130986776a4e6a0c247e752f4d76c4e1702978c06173f2166bc6158b","tests/expanded/many-arguments_async.rs":"cace10ba4f20a04d02e45ac8981dbf63fadfec0efdad3e89cc330e5302101abe","tests/expanded/multi-return.rs":"169d1be739e9fca982bd1492e18b2a8cb25c79fc0ec3ffab2833d03527ecbb9f","tests/expanded/multi-return_async.rs":"12b07b65006449d7a01cabbf1e8e1228cff373c65427c7ae8d273c684c6b3fe5","tests/expanded/multiversion.rs":"3eedf953bc1e0e4ea037757a0fa1b819d749117353545bb3605bc568440d74d1","tests/expanded/multiversion_async.rs":"26dfb6d52ee55652f84d2f366e55cf61c898b1f7266128ba25fbe4b8e14f20dc","tests/expanded/records.rs":"becdfdb99968e644f6bc8993f1f7a176000a187df04f6b20a3ed927a7908d6c4","tests/expanded/records_async.rs":"da2580bc5c6fba3e00cf168019b24fb95631a8b519652977e0f52ea8c3d63302","tests/expanded/rename.rs":"30a7b9f7dbebe253b98aedd5fac0912d21f011222e764787843cbb2bf8baaf9d","tests/expanded/rename_async.rs":"c8c9e7af40d60dc8d6f3f51d44722aa510d61f104380a39fdca43a19da057452","tests/expanded/resources-export.rs":"4b9e7d24138a7a708b3fa243b2ad1d6fc387cab913d08e6ce6202a3b3ac1c019","tests/expanded/resources-export_async.rs":"97efbc786f9f678b46539c4b670d4aac5bc26f12147f130dd54029ef3a8696e7","tests/expanded/resources-import.rs":"25ef7d348363e9dbcc4ba677e29334c81cefe7dc582c9d1926f8589861a7823a","tests/expanded/resources-import_async.rs":"1a8ef6aaf0d79dce613ecf955dd8c438dddd2e9dc6f023fccaefeea446150ce4","tests/expanded/share-types.rs":"a6e631e2a1123328820291ec246fd09ca6631ddfc647892a47feaec34cd0e2f6","tests/expanded/share-types_async.rs":"610b8cd1cb2dc1679696de93e5e2c4d524d53719e814c86244a7a1445427d322","tests/expanded/simple-functions.rs":"71814ac9c1745edba3a895cf083e0bdd15728ffd746715d2ded9098823fbd8af","tests/expanded/simple-functions_async.rs":"a968e6f5b2156376461030d4b39f514e7330224f2d1cdab21161a38b798b3a1e","tests/expanded/simple-lists.rs":"3b678e566b171be47a5e6ed8734a8605e2c77beb68f16d76806d0eb3f8ddc127","tests/expanded/simple-lists_async.rs":"de2028452357898d64cd853a3f311fa9c1f0756fc45835869c490f6c011b6fe1","tests/expanded/simple-wasi.rs":"d25d6ac9c677c1c83c1c8e4adc253620c918cd76066e578b7af93bc86dc1cc1f","tests/expanded/simple-wasi_async.rs":"9b27111673fecb34673e88c26bc9bd3faad7f774381193d29d07a9cc16e248d4","tests/expanded/small-anonymous.rs":"b9c6e5b57adc64fa4fb9f5e7294d00231e689cd8dc97213e5d80cb6b5e03bcba","tests/expanded/small-anonymous_async.rs":"ea378bcdd4bfd6befe07ca139b4be9580aaa6c3789128404b261c66e9c33555c","tests/expanded/smoke-default.rs":"fb7b773ff45cc4af64f01e5cf26e58d5b2b1e0a48b662b38aea9afa0c6e26d2d","tests/expanded/smoke-default_async.rs":"b3a1a696e0d491583de4a6e199876d72e5f7501deaeca52b81163f915c7169f2","tests/expanded/smoke-export.rs":"84f6f67e500a2e9ec20b48f8583207af67ffee91dd6f9f37427199ba21cf4730","tests/expanded/smoke-export_async.rs":"1a2353d72c7e3e941dd6e1eccb33d8722e4f28335fd031b96f1778b7e8b3a026","tests/expanded/smoke.rs":"1699c483fe9ef2d2c93cbc4155df69322d617808bdf69eacbea22bf67fd39964","tests/expanded/smoke_async.rs":"34d9d58bfd1e29175d5cc8654d2c6006334317fff7a1e73a93d5e791db0e78f5","tests/expanded/strings.rs":"ffa1276ced15a246dbdb55ed1c97ac83fd0660ed0c15df272fbfbfba04fb0469","tests/expanded/strings_async.rs":"5abe763281db8f558fef23b0589c587358c40a64f03666411dee341ed5fc0a32","tests/expanded/unversioned-foo.rs":"929caa3b55db4f2d800296ab88f8a3556d7ce5b37db73d491e8c6220f725a712","tests/expanded/unversioned-foo_async.rs":"6f559e9f14620feecce282ab3516ca032d58c6b34b7543f0c1b231d4d62a8cbe","tests/expanded/use-paths.rs":"8be2c9b44dd83cb51fe2081429091ace4209252cf075337b1de4cccc30952f48","tests/expanded/use-paths_async.rs":"db75631108c948382abb6cb35f8dec4ff39252c9757994b137f2b93e6a4dceef","tests/expanded/variants.rs":"2e9b70cc8ba7ac79ca6d980289ce6ad87383fc0d402e4edd8d1023baadef0489","tests/expanded/variants_async.rs":"dd418472c7f94f2f2e82a3565689b172c3c2a16d324b55501d42f0409d5ba30f","tests/expanded/wat.rs":"0f1ea700dab6c3e7d66b42cd031783cff0e2c9f68d6c55084753383cdb0c7bb1","tests/expanded/wat_async.rs":"6725a6d0822d1e0cbcd5648cd24504d0d02632ac71e19ba94ba863a2066c42a8","tests/expanded/worlds-with-types.rs":"147ef9cb28be52d0ae0f5da3f2ee5410fd5fd615592a6b5957cb6edffb67ac1e","tests/expanded/worlds-with-types_async.rs":"3b1b8a43df6fd882956d6fe7699ef29ff7ff445bc3de0ac8f499b70989743113"},"package":"4b07773d1c3dab5f014ec61316ee317aa424033e17e70a63abdf7c3a47e58fcf"}

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

@@ -1,113 +0,0 @@
-# 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 = "24.0.0"
-authors = ["The Wasmtime Project Developers"]
-build = "build.rs"
-autobins = false
-autoexamples = false
-autotests = false
-autobenches = false
-description = "Macros for deriving component interface types from Rust types"
-documentation = "https://docs.rs/wasmtime-component-macro/"
-readme = false
-keywords = [
-    "webassembly",
-    "wasm",
-]
-categories = ["wasm"]
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-
-[lib]
-name = "wasmtime_component_macro"
-path = "src/lib.rs"
-test = false
-doctest = false
-proc-macro = true
-
-[[test]]
-name = "codegen"
-path = "tests/codegen.rs"
-
-[[test]]
-name = "codegen_no_std"
-path = "tests/codegen_no_std.rs"
-
-[[test]]
-name = "expanded"
-path = "tests/expanded.rs"
-
-[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 = "=24.0.0"
-
-[dependencies.wasmtime-wit-bindgen]
-version = "=24.0.0"
-
-[dependencies.wit-parser]
-version = "0.215.0"
-
-[dev-dependencies.prettyplease]
-version = "0.2.19"
-
-[dev-dependencies.serde]
-version = "1.0.188"
-features = [
-    "alloc",
-    "derive",
-]
-default-features = false
-
-[dev-dependencies.serde_json]
-version = "1.0.80"
-
-[dev-dependencies.similar]
-version = "2.1.0"
-
-[dev-dependencies.tracing]
-version = "0.1.26"
-
-[features]
-async = []
-std = ["wasmtime-wit-bindgen/std"]
-
-[lints.clippy]
-clone_on_copy = "warn"
-manual_strip = "warn"
-map_clone = "warn"
-unnecessary_to_owned = "warn"
-
-[lints.clippy.all]
-level = "allow"
-priority = -1
-
-[lints.rust]
-trivial_numeric_casts = "warn"
-unstable_features = "warn"
-unused-lifetimes = "warn"
-unused_extern_crates = "warn"
-unused_import_braces = "warn"

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

@@ -1,500 +0,0 @@
-use proc_macro2::{Span, TokenStream};
-use quote::ToTokens;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::env;
-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, TrappableImports};
-use wit_parser::{PackageId, Resolve, UnresolvedPackageGroup, WorldId};
-
-pub struct Config {
-    opts: Opts,
-    resolve: Resolve,
-    world: WorldId,
-    files: Vec<PathBuf>,
-    include_generated_code_from_file: bool,
-}
-
-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 = match input.opts.generate(&input.resolve, input.world) {
-        Ok(s) => s,
-        Err(e) => return Err(Error::new(Span::call_site(), e.to_string())),
-    };
-
-    if input.opts.stringify {
-        return Ok(quote::quote!(#src));
-    }
-
-    // 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 input.include_generated_code_from_file || 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;
-        let mut features = Vec::new();
-        let mut include_generated_code_from_file = 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::TrappableImports(val) => opts.trappable_imports = 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),
-                    Opt::AdditionalDerives(paths) => {
-                        opts.additional_derive_attributes = paths
-                            .into_iter()
-                            .map(|p| p.into_token_stream().to_string())
-                            .collect()
-                    }
-                    Opt::Stringify(val) => opts.stringify = val,
-                    Opt::SkipMutForwardingImpls(val) => opts.skip_mut_forwarding_impls = val,
-                    Opt::Features(f) => {
-                        features.extend(f.into_iter().map(|f| f.value()));
-                    }
-                    Opt::RequireStoreDataSend(val) => opts.require_store_data_send = val,
-                    Opt::WasmtimeCrate(f) => {
-                        opts.wasmtime_crate = Some(f.into_token_stream().to_string())
-                    }
-                    Opt::IncludeGeneratedCodeFromFile(i) => include_generated_code_from_file = i,
-                }
-            }
-        } 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, &features)
-            .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,
-            include_generated_code_from_file,
-        })
-    }
-}
-
-fn parse_source(
-    path: &Option<String>,
-    inline: &Option<String>,
-    features: &[String],
-) -> anyhow::Result<(Resolve, PackageId, Vec<PathBuf>)> {
-    let mut resolve = Resolve::default();
-    resolve.features.extend(features.iter().cloned());
-    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<_> {
-        // Try to normalize the path to make the error message more understandable when
-        // the path is not correct. Fallback to the original path if normalization fails
-        // (probably return an error somewhere else).
-        let normalized_path = match std::fs::canonicalize(path) {
-            Ok(p) => p,
-            Err(_) => path.to_path_buf(),
-        };
-        let (pkg, sources) = resolve.push_path(normalized_path)?;
-        files.extend(sources);
-        Ok(pkg)
-    };
-
-    let path_pkg = if let Some(path) = path {
-        Some(parse(&mut resolve, &root.join(path))?)
-    } else {
-        None
-    };
-
-    let inline_pkgs = if let Some(inline) = inline {
-        Some(resolve.push_group(UnresolvedPackageGroup::parse("macro-input", inline)?)?)
-    } else {
-        None
-    };
-
-    let pkgs = inline_pkgs
-        .or(path_pkg)
-        .map_or_else(|| parse(&mut resolve, &root.join("wit")), Ok)?;
-
-    Ok((resolve, pkgs, 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);
-    syn::custom_keyword!(trappable_imports);
-    syn::custom_keyword!(additional_derives);
-    syn::custom_keyword!(stringify);
-    syn::custom_keyword!(skip_mut_forwarding_impls);
-    syn::custom_keyword!(features);
-    syn::custom_keyword!(require_store_data_send);
-    syn::custom_keyword!(wasmtime_crate);
-    syn::custom_keyword!(include_generated_code_from_file);
-}
-
-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>),
-    TrappableImports(TrappableImports),
-    AdditionalDerives(Vec<syn::Path>),
-    Stringify(bool),
-    SkipMutForwardingImpls(bool),
-    Features(Vec<syn::LitStr>),
-    RequireStoreDataSend(bool),
-    WasmtimeCrate(syn::Path),
-    IncludeGeneratedCodeFromFile(bool),
-}
-
-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 if l.peek(kw::trappable_imports) {
-            input.parse::<kw::trappable_imports>()?;
-            input.parse::<Token![:]>()?;
-            let config = if input.peek(syn::LitBool) {
-                match input.parse::<syn::LitBool>()?.value {
-                    true => TrappableImports::All,
-                    false => TrappableImports::None,
-                }
-            } else {
-                let contents;
-                syn::bracketed!(contents in input);
-                let fields: Punctuated<syn::LitStr, Token![,]> =
-                    contents.parse_terminated(Parse::parse, Token![,])?;
-                TrappableImports::Only(fields.iter().map(|s| s.value()).collect())
-            };
-            Ok(Opt::TrappableImports(config))
-        } else if l.peek(kw::additional_derives) {
-            input.parse::<kw::additional_derives>()?;
-            input.parse::<Token![:]>()?;
-            let contents;
-            syn::bracketed!(contents in input);
-            let list = Punctuated::<_, Token![,]>::parse_terminated(&contents)?;
-            Ok(Opt::AdditionalDerives(list.iter().cloned().collect()))
-        } else if l.peek(kw::stringify) {
-            input.parse::<kw::stringify>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::Stringify(input.parse::<syn::LitBool>()?.value))
-        } else if l.peek(kw::skip_mut_forwarding_impls) {
-            input.parse::<kw::skip_mut_forwarding_impls>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::SkipMutForwardingImpls(
-                input.parse::<syn::LitBool>()?.value,
-            ))
-        } else if l.peek(kw::features) {
-            input.parse::<kw::features>()?;
-            input.parse::<Token![:]>()?;
-            let contents;
-            syn::bracketed!(contents in input);
-            let list = Punctuated::<_, Token![,]>::parse_terminated(&contents)?;
-            Ok(Opt::Features(list.into_iter().collect()))
-        } else if l.peek(kw::require_store_data_send) {
-            input.parse::<kw::require_store_data_send>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::RequireStoreDataSend(
-                input.parse::<syn::LitBool>()?.value,
-            ))
-        } else if l.peek(kw::wasmtime_crate) {
-            input.parse::<kw::wasmtime_crate>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::WasmtimeCrate(input.parse()?))
-        } else if l.peek(kw::include_generated_code_from_file) {
-            input.parse::<kw::include_generated_code_from_file>()?;
-            input.parse::<Token![:]>()?;
-            Ok(Opt::IncludeGeneratedCodeFromFile(
-                input.parse::<syn::LitBool>()?.value,
-            ))
-        } 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))
-}