wasmtime 20.0.2 → 22.0.0

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

@@ -0,0 +1,427 @@
+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;
+    fn wasmtime_path(&self) -> String;
+
+    /// 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 => {
+                    let wt = self.wasmtime_path();
+                    self.push_str(&format!("{wt}::component::__internal::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 => {
+                let wt = self.wasmtime_path();
+                self.push_str(&format!("{wt}::component::__internal::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,
+        };
+        let wt = self.wasmtime_path();
+        if is_host_defined {
+            self.push_str(&format!("{wt}::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(&format!("{wt}::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/wasmtime-wit-bindgen-22.0.0/src/types.rs

@@ -0,0 +1,202 @@
+use std::collections::HashMap;
+use wit_parser::*;
+
+#[derive(Default)]
+pub struct Types {
+    type_info: HashMap<TypeId, TypeInfo>,
+}
+
+#[derive(Default, Clone, Copy, Debug, PartialEq)]
+pub struct TypeInfo {
+    /// Whether or not this type is ever used (transitively) within a borrowed
+    /// context, or a parameter to an export function.
+    pub borrowed: bool,
+
+    /// Whether or not this type is ever used (transitively) within an owned
+    /// context, such as the result of an exported function or in the params or
+    /// results of an imported function.
+    pub owned: bool,
+
+    /// Whether or not this type is ever used (transitively) within the
+    /// error case in the result of a function.
+    pub error: bool,
+
+    /// Whether or not this type (transitively) has a list.
+    pub has_list: bool,
+
+    /// Whether or not this type (transitively) has a handle.
+    pub has_handle: bool,
+}
+
+impl std::ops::BitOrAssign for TypeInfo {
+    fn bitor_assign(&mut self, rhs: Self) {
+        self.borrowed |= rhs.borrowed;
+        self.owned |= rhs.owned;
+        self.error |= rhs.error;
+        self.has_list |= rhs.has_list;
+        self.has_handle |= rhs.has_handle;
+    }
+}
+
+impl Types {
+    pub fn analyze(&mut self, resolve: &Resolve, world: WorldId) {
+        // Build up all type information first which is inherited through types,
+        // such as properties of borrows/lists/etc.
+        for (t, _) in resolve.types.iter() {
+            self.type_id_info(resolve, t);
+        }
+
+        // ... next handle borrowed/owned flags which aren't inherited through
+        // types.
+        let world = &resolve.worlds[world];
+        for (import, (_, item)) in world
+            .imports
+            .iter()
+            .map(|i| (true, i))
+            .chain(world.exports.iter().map(|i| (false, i)))
+        {
+            match item {
+                WorldItem::Function(f) => self.type_info_func(resolve, f, import),
+                WorldItem::Interface { id, .. } => {
+                    let iface = &resolve.interfaces[*id];
+
+                    for (_, t) in iface.types.iter() {
+                        self.type_id_info(resolve, *t);
+                    }
+                    for (_, f) in iface.functions.iter() {
+                        self.type_info_func(resolve, f, import);
+                    }
+                }
+                WorldItem::Type(id) => {
+                    self.type_id_info(resolve, *id);
+                }
+            }
+        }
+    }
+
+    fn type_info_func(&mut self, resolve: &Resolve, func: &Function, import: bool) {
+        let mut live = LiveTypes::default();
+        for (_, ty) in func.params.iter() {
+            self.type_info(resolve, ty);
+            live.add_type(resolve, ty);
+        }
+        for id in live.iter() {
+            if resolve.types[id].name.is_some() {
+                let info = self.type_info.get_mut(&id).unwrap();
+                if import {
+                    info.owned = true;
+                } else {
+                    info.borrowed = true;
+                }
+            }
+        }
+        let mut live = LiveTypes::default();
+        for ty in func.results.iter_types() {
+            self.type_info(resolve, ty);
+            live.add_type(resolve, ty);
+        }
+        for id in live.iter() {
+            if resolve.types[id].name.is_some() {
+                self.type_info.get_mut(&id).unwrap().owned = true;
+            }
+        }
+
+        for ty in func.results.iter_types() {
+            let id = match ty {
+                Type::Id(id) => *id,
+                _ => continue,
+            };
+            let err = match &resolve.types[id].kind {
+                TypeDefKind::Result(Result_ { err, .. }) => err,
+                _ => continue,
+            };
+            if let Some(Type::Id(id)) = err {
+                let id = super::resolve_type_definition_id(resolve, *id);
+                self.type_info.get_mut(&id).unwrap().error = true;
+            }
+        }
+    }
+
+    pub fn get(&self, id: TypeId) -> TypeInfo {
+        self.type_info[&id]
+    }
+
+    fn type_id_info(&mut self, resolve: &Resolve, ty: TypeId) -> TypeInfo {
+        if let Some(info) = self.type_info.get(&ty) {
+            return *info;
+        }
+        let mut info = TypeInfo::default();
+        match &resolve.types[ty].kind {
+            TypeDefKind::Record(r) => {
+                for field in r.fields.iter() {
+                    info |= self.type_info(resolve, &field.ty);
+                }
+            }
+            TypeDefKind::Tuple(t) => {
+                for ty in t.types.iter() {
+                    info |= self.type_info(resolve, ty);
+                }
+            }
+            TypeDefKind::Flags(_) => {}
+            TypeDefKind::Enum(_) => {}
+            TypeDefKind::Variant(v) => {
+                for case in v.cases.iter() {
+                    info |= self.optional_type_info(resolve, case.ty.as_ref());
+                }
+            }
+            TypeDefKind::List(ty) => {
+                info = self.type_info(resolve, ty);
+                info.has_list = true;
+            }
+            TypeDefKind::Type(ty) => {
+                info = self.type_info(resolve, ty);
+            }
+            TypeDefKind::Option(ty) => {
+                info = self.type_info(resolve, ty);
+            }
+            TypeDefKind::Result(r) => {
+                info = self.optional_type_info(resolve, r.ok.as_ref());
+                info |= self.optional_type_info(resolve, r.err.as_ref());
+            }
+            TypeDefKind::Future(ty) => {
+                info = self.optional_type_info(resolve, ty.as_ref());
+            }
+            TypeDefKind::Stream(stream) => {
+                info = self.optional_type_info(resolve, stream.element.as_ref());
+                info |= self.optional_type_info(resolve, stream.end.as_ref());
+            }
+            TypeDefKind::Handle(_) => info.has_handle = true,
+            TypeDefKind::Resource => {}
+            TypeDefKind::Unknown => unreachable!(),
+        }
+        self.type_info.insert(ty, info);
+        info
+    }
+
+    fn type_info(&mut self, resolve: &Resolve, ty: &Type) -> TypeInfo {
+        let mut info = TypeInfo::default();
+        match ty {
+            Type::String => info.has_list = true,
+            Type::Id(id) => return self.type_id_info(resolve, *id),
+            _ => {}
+        }
+        info
+    }
+
+    fn optional_type_info(&mut self, resolve: &Resolve, ty: Option<&Type>) -> TypeInfo {
+        match ty {
+            Some(ty) => self.type_info(resolve, ty),
+            None => TypeInfo::default(),
+        }
+    }
+}
+
+impl TypeInfo {
+    pub fn is_copy(&self) -> bool {
+        !self.has_list && !self.has_handle
+    }
+
+    pub fn is_clone(&self) -> bool {
+        !self.has_handle
+    }
+}

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

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"e5887f38680dc4d5d2894e2bd3f0029d64c7fc76c2bf51155a742159bc36961e","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"21422dca0d2d4fd0e55a8cb795e26fc5ba1d6ca84c309c8d7f2344b1b47bdf17","src/error.rs":"deb6a444431fe40eef837b5db8f4f5fa82ef8a03bb9957c3688895d5f6d7bd20","src/guest_type.rs":"c4d657ae16169e0d8118afbfb1481ab6d6420240c4761c01a52ae5507435f6b5","src/lib.rs":"c707d5386f72b2c78945ae24214de225cb4699e8475da18c1399e04ecd377c26","src/region.rs":"5a4e9284148747f00dbe08831b87c5c2528e68eff266a6f1996fcb11d00ed821"},"package":"29830e5d01c182d24b94092c697aa7ab0ee97d22e78a2bf40ca91eae6ebca5c2"}