wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/wasmtime-wit-bindgen-20.0.2/src/rust.rs

@@ -1,421 +0,0 @@
-use crate::{types::TypeInfo, Ownership};
-use heck::*;
-use wit_parser::*;
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum TypeMode {
-    Owned,
-    AllBorrowed(&'static str),
-}
-
-pub trait RustGenerator<'a> {
-    fn resolve(&self) -> &'a Resolve;
-
-    fn push_str(&mut self, s: &str);
-    fn info(&self, ty: TypeId) -> TypeInfo;
-    fn path_to_interface(&self, interface: InterfaceId) -> Option<String>;
-    fn is_imported_interface(&self, interface: InterfaceId) -> bool;
-
-    /// This determines whether we generate owning types or (where appropriate)
-    /// borrowing types.
-    ///
-    /// For example, when generating a type which is only used as a parameter to
-    /// a guest-exported function, there is no need for it to own its fields.
-    /// However, constructing deeply-nested borrows (e.g. `&[&[&[&str]]]]` for
-    /// `list<list<list<string>>>`) can be very awkward, so by default we
-    /// generate owning types and use only shallow borrowing at the top level
-    /// inside function signatures.
-    fn ownership(&self) -> Ownership;
-
-    fn print_ty(&mut self, ty: &Type, mode: TypeMode) {
-        match ty {
-            Type::Id(t) => self.print_tyid(*t, mode),
-            Type::Bool => self.push_str("bool"),
-            Type::U8 => self.push_str("u8"),
-            Type::U16 => self.push_str("u16"),
-            Type::U32 => self.push_str("u32"),
-            Type::U64 => self.push_str("u64"),
-            Type::S8 => self.push_str("i8"),
-            Type::S16 => self.push_str("i16"),
-            Type::S32 => self.push_str("i32"),
-            Type::S64 => self.push_str("i64"),
-            Type::F32 => self.push_str("f32"),
-            Type::F64 => self.push_str("f64"),
-            Type::Char => self.push_str("char"),
-            Type::String => match mode {
-                TypeMode::AllBorrowed(lt) => {
-                    self.push_str("&");
-                    if lt != "'_" {
-                        self.push_str(lt);
-                        self.push_str(" ");
-                    }
-                    self.push_str("str");
-                }
-                TypeMode::Owned => self.push_str("String"),
-            },
-        }
-    }
-
-    fn print_optional_ty(&mut self, ty: Option<&Type>, mode: TypeMode) {
-        match ty {
-            Some(ty) => self.print_ty(ty, mode),
-            None => self.push_str("()"),
-        }
-    }
-
-    fn print_tyid(&mut self, id: TypeId, mode: TypeMode) {
-        let info = self.info(id);
-        let lt = self.lifetime_for(&info, mode);
-        let ty = &self.resolve().types[id];
-        if ty.name.is_some() {
-            // If this type has a list internally, no lifetime is being printed,
-            // but we're in a borrowed mode, then that means we're in a borrowed
-            // context and don't want ownership of the type but we're using an
-            // owned type definition. Inject a `&` in front to indicate that, at
-            // the API level, ownership isn't required.
-            if info.has_list && lt.is_none() {
-                if let TypeMode::AllBorrowed(lt) = mode {
-                    self.push_str("&");
-                    if lt != "'_" {
-                        self.push_str(lt);
-                        self.push_str(" ");
-                    }
-                }
-            }
-            let name = if lt.is_some() {
-                self.param_name(id)
-            } else {
-                self.result_name(id)
-            };
-            self.print_type_name_in_interface(ty.owner, &name);
-
-            // If the type recursively owns data and it's a
-            // variant/record/list, then we need to place the
-            // lifetime parameter on the type as well.
-            if info.has_list && needs_generics(self.resolve(), &ty.kind) {
-                self.print_generics(lt);
-            }
-
-            return;
-
-            fn needs_generics(resolve: &Resolve, ty: &TypeDefKind) -> bool {
-                match ty {
-                    TypeDefKind::Variant(_)
-                    | TypeDefKind::Record(_)
-                    | TypeDefKind::Option(_)
-                    | TypeDefKind::Result(_)
-                    | TypeDefKind::Future(_)
-                    | TypeDefKind::Stream(_)
-                    | TypeDefKind::List(_)
-                    | TypeDefKind::Flags(_)
-                    | TypeDefKind::Enum(_)
-                    | TypeDefKind::Tuple(_)
-                    | TypeDefKind::Handle(_)
-                    | TypeDefKind::Resource => true,
-                    TypeDefKind::Type(Type::Id(t)) => {
-                        needs_generics(resolve, &resolve.types[*t].kind)
-                    }
-                    TypeDefKind::Type(Type::String) => true,
-                    TypeDefKind::Type(_) => false,
-                    TypeDefKind::Unknown => unreachable!(),
-                }
-            }
-        }
-
-        match &ty.kind {
-            TypeDefKind::List(t) => self.print_list(t, mode),
-
-            TypeDefKind::Option(t) => {
-                self.push_str("Option<");
-                self.print_ty(t, mode);
-                self.push_str(">");
-            }
-
-            TypeDefKind::Result(r) => {
-                self.push_str("Result<");
-                self.print_optional_ty(r.ok.as_ref(), mode);
-                self.push_str(",");
-                self.print_optional_ty(r.err.as_ref(), mode);
-                self.push_str(">");
-            }
-
-            TypeDefKind::Variant(_) => panic!("unsupported anonymous variant"),
-
-            // Tuple-like records are mapped directly to Rust tuples of
-            // types. Note the trailing comma after each member to
-            // appropriately handle 1-tuples.
-            TypeDefKind::Tuple(t) => {
-                self.push_str("(");
-                for ty in t.types.iter() {
-                    self.print_ty(ty, mode);
-                    self.push_str(",");
-                }
-                self.push_str(")");
-            }
-            TypeDefKind::Record(_) => {
-                panic!("unsupported anonymous type reference: record")
-            }
-            TypeDefKind::Flags(_) => {
-                panic!("unsupported anonymous type reference: flags")
-            }
-            TypeDefKind::Enum(_) => {
-                panic!("unsupported anonymous type reference: enum")
-            }
-            TypeDefKind::Future(ty) => {
-                self.push_str("Future<");
-                self.print_optional_ty(ty.as_ref(), mode);
-                self.push_str(">");
-            }
-            TypeDefKind::Stream(stream) => {
-                self.push_str("Stream<");
-                self.print_optional_ty(stream.element.as_ref(), mode);
-                self.push_str(",");
-                self.print_optional_ty(stream.end.as_ref(), mode);
-                self.push_str(">");
-            }
-
-            TypeDefKind::Handle(handle) => {
-                self.print_handle(handle);
-            }
-            TypeDefKind::Resource => unreachable!(),
-
-            TypeDefKind::Type(t) => self.print_ty(t, mode),
-            TypeDefKind::Unknown => unreachable!(),
-        }
-    }
-
-    fn print_type_name_in_interface(&mut self, owner: TypeOwner, name: &str) {
-        if let TypeOwner::Interface(id) = owner {
-            if let Some(path) = self.path_to_interface(id) {
-                self.push_str(&path);
-                self.push_str("::");
-            }
-        }
-        self.push_str(name);
-    }
-
-    fn print_list(&mut self, ty: &Type, mode: TypeMode) {
-        let next_mode = if matches!(self.ownership(), Ownership::Owning) {
-            TypeMode::Owned
-        } else {
-            mode
-        };
-        match mode {
-            TypeMode::AllBorrowed(lt) => {
-                self.push_str("&");
-                if lt != "'_" {
-                    self.push_str(lt);
-                    self.push_str(" ");
-                }
-                self.push_str("[");
-                self.print_ty(ty, next_mode);
-                self.push_str("]");
-            }
-            TypeMode::Owned => {
-                self.push_str("Vec<");
-                self.print_ty(ty, next_mode);
-                self.push_str(">");
-            }
-        }
-    }
-
-    fn print_handle(&mut self, handle: &Handle) {
-        // Handles are either printed as `ResourceAny` for any guest-defined
-        // resource or `Resource<T>` for all host-defined resources. This means
-        // that this function needs to determine if `handle` points to a host
-        // or a guest resource which is determined by:
-        //
-        // * For world-owned resources, they're always imported.
-        // * For interface-owned resources, it depends on the how bindings were
-        //   last generated for this interface.
-        //
-        // Additionally type aliases via `use` are "peeled" here to find the
-        // original definition of the resource since that's the one that we
-        // care about for determining whether it's imported or not.
-        let resource = match handle {
-            Handle::Own(t) | Handle::Borrow(t) => *t,
-        };
-        let ty = &self.resolve().types[resource];
-        let def_id = super::resolve_type_definition_id(self.resolve(), resource);
-        let ty_def = &self.resolve().types[def_id];
-        let is_host_defined = match ty_def.owner {
-            TypeOwner::Interface(i) => self.is_imported_interface(i),
-            _ => true,
-        };
-        if is_host_defined {
-            self.push_str("wasmtime::component::Resource<");
-            self.print_type_name_in_interface(
-                ty.owner,
-                &ty.name.as_ref().unwrap().to_upper_camel_case(),
-            );
-            self.push_str(">");
-        } else {
-            self.push_str("wasmtime::component::ResourceAny");
-        }
-    }
-
-    fn print_generics(&mut self, lifetime: Option<&str>) {
-        if lifetime.is_none() {
-            return;
-        }
-        self.push_str("<");
-        if let Some(lt) = lifetime {
-            self.push_str(lt);
-            self.push_str(",");
-        }
-        self.push_str(">");
-    }
-
-    fn modes_of(&self, ty: TypeId) -> Vec<(String, TypeMode)> {
-        let info = self.info(ty);
-        if !info.owned && !info.borrowed {
-            return Vec::new();
-        }
-        let mut result = Vec::new();
-        let first_mode =
-            if info.owned || !info.borrowed || matches!(self.ownership(), Ownership::Owning) {
-                TypeMode::Owned
-            } else {
-                assert!(!self.uses_two_names(&info));
-                TypeMode::AllBorrowed("'a")
-            };
-        result.push((self.result_name(ty), first_mode));
-        if self.uses_two_names(&info) {
-            result.push((self.param_name(ty), TypeMode::AllBorrowed("'a")));
-        }
-        result
-    }
-
-    fn param_name(&self, ty: TypeId) -> String {
-        let info = self.info(ty);
-        let name = self.resolve().types[ty]
-            .name
-            .as_ref()
-            .unwrap()
-            .to_upper_camel_case();
-        if self.uses_two_names(&info) {
-            format!("{}Param", name)
-        } else {
-            name
-        }
-    }
-
-    fn result_name(&self, ty: TypeId) -> String {
-        let info = self.info(ty);
-        let name = self.resolve().types[ty]
-            .name
-            .as_ref()
-            .unwrap()
-            .to_upper_camel_case();
-        if self.uses_two_names(&info) {
-            format!("{}Result", name)
-        } else {
-            name
-        }
-    }
-
-    fn uses_two_names(&self, info: &TypeInfo) -> bool {
-        info.has_list
-            && info.borrowed
-            && info.owned
-            && matches!(
-                self.ownership(),
-                Ownership::Borrowing {
-                    duplicate_if_necessary: true
-                }
-            )
-    }
-
-    fn lifetime_for(&self, info: &TypeInfo, mode: TypeMode) -> Option<&'static str> {
-        if matches!(self.ownership(), Ownership::Owning) {
-            return None;
-        }
-        let lt = match mode {
-            TypeMode::AllBorrowed(s) => s,
-            _ => return None,
-        };
-        // No lifetimes needed unless this has a list.
-        if !info.has_list {
-            return None;
-        }
-        // If two names are used then this type will have an owned and a
-        // borrowed copy and the borrowed copy is being used, so it needs a
-        // lifetime. Otherwise if it's only borrowed and not owned then this can
-        // also use a lifetime since it's not needed in two contexts and only
-        // the borrowed version of the structure was generated.
-        if self.uses_two_names(info) || (info.borrowed && !info.owned) {
-            Some(lt)
-        } else {
-            None
-        }
-    }
-}
-
-/// Translate `name` to a Rust `snake_case` identifier.
-pub fn to_rust_ident(name: &str) -> String {
-    match name {
-        // Escape Rust keywords.
-        // Source: https://doc.rust-lang.org/reference/keywords.html
-        "as" => "as_".into(),
-        "break" => "break_".into(),
-        "const" => "const_".into(),
-        "continue" => "continue_".into(),
-        "crate" => "crate_".into(),
-        "else" => "else_".into(),
-        "enum" => "enum_".into(),
-        "extern" => "extern_".into(),
-        "false" => "false_".into(),
-        "fn" => "fn_".into(),
-        "for" => "for_".into(),
-        "if" => "if_".into(),
-        "impl" => "impl_".into(),
-        "in" => "in_".into(),
-        "let" => "let_".into(),
-        "loop" => "loop_".into(),
-        "match" => "match_".into(),
-        "mod" => "mod_".into(),
-        "move" => "move_".into(),
-        "mut" => "mut_".into(),
-        "pub" => "pub_".into(),
-        "ref" => "ref_".into(),
-        "return" => "return_".into(),
-        "self" => "self_".into(),
-        "static" => "static_".into(),
-        "struct" => "struct_".into(),
-        "super" => "super_".into(),
-        "trait" => "trait_".into(),
-        "true" => "true_".into(),
-        "type" => "type_".into(),
-        "unsafe" => "unsafe_".into(),
-        "use" => "use_".into(),
-        "where" => "where_".into(),
-        "while" => "while_".into(),
-        "async" => "async_".into(),
-        "await" => "await_".into(),
-        "dyn" => "dyn_".into(),
-        "abstract" => "abstract_".into(),
-        "become" => "become_".into(),
-        "box" => "box_".into(),
-        "do" => "do_".into(),
-        "final" => "final_".into(),
-        "macro" => "macro_".into(),
-        "override" => "override_".into(),
-        "priv" => "priv_".into(),
-        "typeof" => "typeof_".into(),
-        "unsized" => "unsized_".into(),
-        "virtual" => "virtual_".into(),
-        "yield" => "yield_".into(),
-        "try" => "try_".into(),
-        s => s.to_snake_case(),
-    }
-}
-
-/// Translate `name` to a Rust `UpperCamelCase` identifier.
-pub fn to_rust_upper_camel_case(name: &str) -> String {
-    match name {
-        // We use `Host` as the name of the trait for host implementations
-        // to fill in, so rename it if "Host" is used as a regular identifier.
-        "host" => "Host_".into(),
-        s => s.to_upper_camel_case(),
-    }
-}

data/ext/cargo-vendor/wiggle-20.0.2/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"b469bdd8886b8dae818b75724beb965132a3796e11000543cdf75f08ba43f1e4","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"21422dca0d2d4fd0e55a8cb795e26fc5ba1d6ca84c309c8d7f2344b1b47bdf17","src/borrow.rs":"1f022ac413d07ea01a5e1a8740ae656d42a33e224cf1abb8222cfa0aa2bc7bb3","src/error.rs":"deb6a444431fe40eef837b5db8f4f5fa82ef8a03bb9957c3688895d5f6d7bd20","src/guest_type.rs":"3f729ef3c41b3a216afc8a8c8b7f904bf0addb75861bb7f98cdff33d89c7d17f","src/lib.rs":"3f3ec0137c5498f4d35e10aa0d2fc60fc88e756cb8d8bf8dcf7bac71c64388f7","src/region.rs":"5a4e9284148747f00dbe08831b87c5c2528e68eff266a6f1996fcb11d00ed821","src/wasmtime.rs":"2afdc1d14c4099f903b5bb9f9cbd54ebd60532c36eb39eecfc41319948407766"},"package":"f93fc3510978a905f931d74784ed8685bd6453e18ad8f92809e793d48827e3cd"}

data/ext/cargo-vendor/wiggle-20.0.2/Cargo.toml

@@ -1,122 +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 = "wiggle"
-version = "20.0.2"
-authors = [
-    "Pat Hickey <phickey@fastly.com>",
-    "Jakub Konka <kubkonk@jakubkonka.com>",
-    "Alex Crichton <alex@alexcrichton.com>",
-]
-include = [
-    "src/**/*",
-    "README.md",
-    "LICENSE",
-]
-description = "Runtime components of wiggle code generator"
-readme = "README.md"
-keywords = [
-    "webassembly",
-    "wasm",
-]
-categories = ["wasm"]
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-
-[[test]]
-name = "atoms_async"
-path = "tests/atoms_async.rs"
-required-features = ["wasmtime_async"]
-
-[[test]]
-name = "wasmtime_async"
-path = "tests/wasmtime_async.rs"
-required-features = [
-    "wasmtime_async",
-    "wasmtime/wat",
-]
-
-[[test]]
-name = "wasmtime_sync"
-path = "tests/wasmtime_sync.rs"
-required-features = ["wasmtime/wat"]
-
-[[test]]
-name = "wasmtime_integration"
-path = "tests/wasmtime_integration.rs"
-required-features = ["wasmtime/wat"]
-
-[dependencies.anyhow]
-version = "1.0.22"
-
-[dependencies.async-trait]
-version = "0.1.71"
-
-[dependencies.bitflags]
-version = "2.0"
-
-[dependencies.thiserror]
-version = "1.0.43"
-
-[dependencies.tracing]
-version = "0.1.26"
-
-[dependencies.wasmtime]
-version = "20.0.2"
-optional = true
-default-features = false
-
-[dependencies.wiggle-macro]
-version = "=20.0.2"
-
-[dependencies.witx]
-version = "0.9.1"
-optional = true
-
-[dev-dependencies.proptest]
-version = "1.0.0"
-
-[dev-dependencies.tokio]
-version = "1"
-features = [
-    "rt-multi-thread",
-    "time",
-    "macros",
-]
-
-[dev-dependencies.wasmtime]
-version = "20.0.2"
-default-features = false
-
-[features]
-default = [
-    "wiggle_metadata",
-    "wasmtime",
-    "wasmtime_async",
-]
-tracing_log = ["tracing/log"]
-wasmtime = ["dep:wasmtime"]
-wasmtime_async = ["wasmtime/async"]
-wiggle_metadata = [
-    "witx",
-    "wiggle-macro/wiggle_metadata",
-]
-
-[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/wiggle-generate-20.0.2/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"3a8cf9caa175a932fc84ea324647e917d8e93e972d26a955c7d8481b0d3a44f5","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"eb29b0dead8b5ff41ac51282bfa041e9c122c7c10395e2c8e0050972b7edaa9b","src/codegen_settings.rs":"f53f89264a5bbd7a62a1e1c931539d5054f0030a747a485e9b0b9d65106dd7e8","src/config.rs":"64be20113d788bf7e1aab7e16271384e5784d13b1ffb9bba43e1cc4b33cde619","src/funcs.rs":"8279c990d18a213e3c541bb8739f222b341d9fbbbf9998ad8203246edb3af95d","src/lib.rs":"5f6ec829e43dc37427fefea20aa625e60d91d5dc408a9befa643becf5adef0fa","src/lifetimes.rs":"4b54f556048732580daf5b238963277c61096bc8c2b7bd012d0c2a6771b4cddb","src/module_trait.rs":"95dff309611fbb406506cd394a01a9da23a930c12f56cb3acc5b839f3181c2a0","src/names.rs":"19a579dea7c5631105105a21e42d5cdafe773b2e33dc117adc36333bc0b88b2a","src/types/error.rs":"e21302d7f2cf59161566e7f224c70cd892694f1ea173fb205db0c2cb82c40e2c","src/types/flags.rs":"cc125979ca890fcb2ae7d8fb04452f633830e9e5ab3ac7d97697a779e61246c9","src/types/handle.rs":"76f867db75c665ab617e8c96d54f27c6e773c3eda513f6b5f4fb7ef1def99162","src/types/mod.rs":"f3dcfcf064abf4475e132eb6793211f6b79b937becd658a38401a2c06634135c","src/types/record.rs":"59fedf459446f2fc95247faad64aed465dbc5d634321ec468724a0f8db7d1fce","src/types/variant.rs":"dc7aaa915f6fd783ea729893820f0fb9f5ffe9406abbb6dcec775d7c7021fb5e","src/wasmtime.rs":"61cb4b0ad6b7749a052dc5c540b48354651a56a3a77a1042ed60237c37807baf"},"package":"4ec3909e70f36066526ad3b2abb4855ab836f8a6b293449582563ac50d651083"}

data/ext/cargo-vendor/wiggle-generate-20.0.2/Cargo.toml

@@ -1,65 +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 = "wiggle-generate"
-version = "20.0.2"
-authors = [
-    "Pat Hickey <phickey@fastly.com>",
-    "Jakub Konka <kubkon@jakubkonka.com>",
-    "Alex Crichton <alex@alexcrichton.com>",
-]
-include = [
-    "src/**/*",
-    "README.md",
-    "LICENSE",
-]
-description = "Library crate for wiggle code generator."
-readme = "README.md"
-keywords = [
-    "webassembly",
-    "wasm",
-]
-categories = ["wasm"]
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-
-[dependencies.anyhow]
-version = "1.0.22"
-
-[dependencies.heck]
-version = "0.4"
-
-[dependencies.proc-macro2]
-version = "1.0"
-
-[dependencies.quote]
-version = "1.0"
-
-[dependencies.shellexpand]
-version = "2.0"
-
-[dependencies.syn]
-version = "2.0.25"
-features = ["full"]
-
-[dependencies.witx]
-version = "0.9.1"
-
-[lints.clippy]
-all = "allow"
-
-[lints.rust]
-trivial_numeric_casts = "warn"
-unstable_features = "warn"
-unused_extern_crates = "warn"
-unused_import_braces = "warn"