wasmtime 21.0.1 → 22.0.0

data/ext/cargo-vendor/wiggle-generate-22.0.0/src/names.rs

@@ -0,0 +1,299 @@
+use escaping::{escape_id, handle_2big_enum_variant, NamingConvention};
+use heck::{ToShoutySnakeCase, ToSnakeCase};
+use proc_macro2::{Ident, TokenStream};
+use quote::{format_ident, quote};
+use witx::{BuiltinType, Id, Type, TypeRef, WasmType};
+
+use crate::UserErrorType;
+
+pub fn type_(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::CamelCase)
+}
+
+pub fn builtin_type(b: BuiltinType) -> TokenStream {
+    match b {
+        BuiltinType::U8 { .. } => quote!(u8),
+        BuiltinType::U16 => quote!(u16),
+        BuiltinType::U32 { .. } => quote!(u32),
+        BuiltinType::U64 => quote!(u64),
+        BuiltinType::S8 => quote!(i8),
+        BuiltinType::S16 => quote!(i16),
+        BuiltinType::S32 => quote!(i32),
+        BuiltinType::S64 => quote!(i64),
+        BuiltinType::F32 => quote!(f32),
+        BuiltinType::F64 => quote!(f64),
+        BuiltinType::Char => quote!(char),
+    }
+}
+
+pub fn wasm_type(ty: WasmType) -> TokenStream {
+    match ty {
+        WasmType::I32 => quote!(i32),
+        WasmType::I64 => quote!(i64),
+        WasmType::F32 => quote!(f32),
+        WasmType::F64 => quote!(f64),
+    }
+}
+
+pub fn type_ref(tref: &TypeRef, lifetime: TokenStream) -> TokenStream {
+    match tref {
+        TypeRef::Name(nt) => {
+            let ident = type_(&nt.name);
+            quote!(#ident)
+        }
+        TypeRef::Value(ty) => match &**ty {
+            Type::Builtin(builtin) => builtin_type(*builtin),
+            Type::Pointer(pointee) | Type::ConstPointer(pointee) => {
+                let pointee_type = type_ref(&pointee, lifetime.clone());
+                quote!(wiggle::GuestPtr<#pointee_type>)
+            }
+            Type::List(pointee) => match &**pointee.type_() {
+                Type::Builtin(BuiltinType::Char) => {
+                    quote!(wiggle::GuestPtr<str>)
+                }
+                _ => {
+                    let pointee_type = type_ref(&pointee, lifetime.clone());
+                    quote!(wiggle::GuestPtr<[#pointee_type]>)
+                }
+            },
+            Type::Variant(v) => match v.as_expected() {
+                Some((ok, err)) => {
+                    let ok = match ok {
+                        Some(ty) => type_ref(ty, lifetime.clone()),
+                        None => quote!(()),
+                    };
+                    let err = match err {
+                        Some(ty) => type_ref(ty, lifetime.clone()),
+                        None => quote!(()),
+                    };
+                    quote!(Result<#ok, #err>)
+                }
+                None => unimplemented!("anonymous variant ref {:?}", tref),
+            },
+            Type::Record(r) if r.is_tuple() => {
+                let types = r
+                    .members
+                    .iter()
+                    .map(|m| type_ref(&m.tref, lifetime.clone()))
+                    .collect::<Vec<_>>();
+                quote!((#(#types,)*))
+            }
+            _ => unimplemented!("anonymous type ref {:?}", tref),
+        },
+    }
+}
+
+/// Convert an enum variant from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn enum_variant(id: &Id) -> Ident {
+    handle_2big_enum_variant(id).unwrap_or_else(|| escape_id(id, NamingConvention::CamelCase))
+}
+
+pub fn flag_member(id: &Id) -> Ident {
+    format_ident!("{}", id.as_str().to_shouty_snake_case())
+}
+
+pub fn int_member(id: &Id) -> Ident {
+    format_ident!("{}", id.as_str().to_shouty_snake_case())
+}
+
+/// Convert a struct member from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn struct_member(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::SnakeCase)
+}
+
+/// Convert a module name from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn module(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::SnakeCase)
+}
+
+/// Convert a trait name from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn trait_name(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::CamelCase)
+}
+
+/// Convert a function name from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn func(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::SnakeCase)
+}
+
+/// Convert a parameter name from its [`Id`][witx] name to its Rust [`Ident`][id] representation.
+///
+/// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+/// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+pub fn func_param(id: &Id) -> Ident {
+    escape_id(id, NamingConvention::SnakeCase)
+}
+
+/// For when you need a {name}_ptr binding for passing a value by reference:
+pub fn func_ptr_binding(id: &Id) -> Ident {
+    format_ident!("{}_ptr", id.as_str().to_snake_case())
+}
+
+/// For when you need a {name}_len binding for passing an array:
+pub fn func_len_binding(id: &Id) -> Ident {
+    format_ident!("{}_len", id.as_str().to_snake_case())
+}
+
+fn builtin_name(b: &BuiltinType) -> &'static str {
+    match b {
+        BuiltinType::U8 { .. } => "u8",
+        BuiltinType::U16 => "u16",
+        BuiltinType::U32 { .. } => "u32",
+        BuiltinType::U64 => "u64",
+        BuiltinType::S8 => "i8",
+        BuiltinType::S16 => "i16",
+        BuiltinType::S32 => "i32",
+        BuiltinType::S64 => "i64",
+        BuiltinType::F32 => "f32",
+        BuiltinType::F64 => "f64",
+        BuiltinType::Char => "char",
+    }
+}
+
+fn snake_typename(tref: &TypeRef) -> String {
+    match tref {
+        TypeRef::Name(nt) => nt.name.as_str().to_snake_case(),
+        TypeRef::Value(ty) => match &**ty {
+            Type::Builtin(b) => builtin_name(&b).to_owned(),
+            _ => panic!("unexpected anonymous type: {:?}", ty),
+        },
+    }
+}
+
+pub fn user_error_conversion_method(user_type: &UserErrorType) -> Ident {
+    let abi_type = snake_typename(&user_type.abi_type());
+    format_ident!(
+        "{}_from_{}",
+        abi_type,
+        user_type.method_fragment().to_snake_case()
+    )
+}
+
+/// Identifier escaping utilities.
+///
+/// This module most importantly exports an `escape_id` function that can be used to properly
+/// escape tokens that conflict with strict and reserved keywords, as of Rust's 2018 edition.
+///
+/// Weak keywords are not included as their semantic rules do not have the same implications as
+/// those of strict and reserved keywords. `union` for example, is permitted as the name of a
+/// variable. `dyn` was promoted to a strict keyword beginning in the 2018 edition.
+mod escaping {
+    use {
+        heck::{ToSnakeCase, ToUpperCamelCase},
+        proc_macro2::Ident,
+        quote::format_ident,
+        witx::Id,
+    };
+
+    /// Identifier naming convention.
+    ///
+    /// Because shouty snake case values (identifiers that look `LIKE_THIS`) cannot potentially
+    /// conflict with any Rust keywords, this enum only include snake and camel case variants.
+    pub enum NamingConvention {
+        /// Snake case. Used to denote values `LikeThis`.
+        CamelCase,
+        /// Snake case. Used to denote values `like_this`.
+        SnakeCase,
+    }
+
+    /// Given a witx [`Id`][witx] and a [`NamingConvention`][naming], return a [`Ident`] word of
+    /// Rust syntax that accounts for escaping both strict and reserved keywords. If an identifier
+    /// would have conflicted with a keyword, a trailing underscode will be appended.
+    ///
+    /// [id]: https://docs.rs/proc-macro2/*/proc_macro2/struct.Ident.html
+    /// [naming]: enum.NamingConvention.html
+    /// [witx]: https://docs.rs/witx/*/witx/struct.Id.html
+    pub fn escape_id(id: &Id, conv: NamingConvention) -> Ident {
+        use NamingConvention::{CamelCase, SnakeCase};
+        match (conv, id.as_str()) {
+            // For camel-cased identifiers, `Self` is the only potential keyword conflict.
+            (CamelCase, "self") => format_ident!("Self_"),
+            (CamelCase, s) => format_ident!("{}", s.to_upper_camel_case()),
+            // Snake-cased identifiers are where the bulk of conflicts can occur.
+            (SnakeCase, s) => {
+                let s = s.to_snake_case();
+                if STRICT.iter().chain(RESERVED).any(|k| *k == s) {
+                    // If the camel-cased string matched any strict or reserved keywords, then
+                    // append a trailing underscore to the identifier we generate.
+                    format_ident!("{}_", s)
+                } else {
+                    format_ident!("{}", s) // Otherwise, use the string as is.
+                }
+            }
+        }
+    }
+
+    /// Strict keywords.
+    ///
+    /// >  Strict keywords cannot be used as the names of:
+    /// >    * Items
+    /// >    * Variables and function parameters
+    /// >    * Fields and variants
+    /// >    * Type parameters
+    /// >    * Lifetime parameters or loop labels
+    /// >    * Macros or attributes
+    /// >    * Macro placeholders
+    /// >    * Crates
+    /// >
+    /// > - <cite>[The Rust Reference][ref]</cite>
+    ///
+    /// This list also includes keywords that were introduced in the 2018 edition of Rust.
+    ///
+    /// [ref]: https://doc.rust-lang.org/reference/keywords.html#strict-keywords
+    const STRICT: &[&str] = &[
+        "as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum",
+        "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod", "move",
+        "mut", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait",
+        "true", "type", "unsafe", "use", "where", "while",
+    ];
+
+    /// Reserved keywords.
+    ///
+    /// > These keywords aren't used yet, but they are reserved for future use. They have the same
+    /// > restrictions as strict keywords. The reasoning behind this is to make current programs
+    /// > forward compatible with future versions of Rust by forbidding them to use these keywords.
+    /// >
+    /// > - <cite>[The Rust Reference][ref]</cite>
+    ///
+    /// This list also includes keywords that were introduced in the 2018 edition of Rust.
+    ///
+    /// [ref]: https://doc.rust-lang.org/reference/keywords.html#reserved-keywords
+    const RESERVED: &[&str] = &[
+        "abstract", "become", "box", "do", "final", "macro", "override", "priv", "try", "typeof",
+        "unsized", "virtual", "yield",
+    ];
+
+    /// Handle WASI's [`errno::2big`][err] variant.
+    ///
+    /// This is an unfortunate edge case that must account for when generating `enum` variants.
+    /// This will only return `Some(_)` if the given witx identifier *is* `2big`, otherwise this
+    /// function will return `None`.
+    ///
+    /// This functionality is a short-term fix that keeps WASI working. Instead of expanding these sort of special cases,
+    /// we should replace this function by having the user provide a mapping of witx identifiers to Rust identifiers in the
+    /// arguments to the macro.
+    ///
+    /// [err]: https://github.com/WebAssembly/WASI/blob/master/phases/snapshot/docs.md#-errno-enumu16
+    pub fn handle_2big_enum_variant(id: &Id) -> Option<Ident> {
+        if id.as_str() == "2big" {
+            Some(format_ident!("TooBig"))
+        } else {
+            None
+        }
+    }
+}

data/ext/cargo-vendor/wiggle-generate-22.0.0/src/types/flags.rs

@@ -0,0 +1,92 @@
+use crate::names;
+
+use proc_macro2::{Literal, TokenStream};
+use quote::quote;
+
+pub(super) fn define_flags(
+    name: &witx::Id,
+    repr: witx::IntRepr,
+    record: &witx::RecordDatatype,
+) -> TokenStream {
+    let ident = names::type_(&name);
+    let abi_repr = names::wasm_type(repr.into());
+    let repr = super::int_repr_tokens(repr);
+
+    let mut names_ = vec![];
+    let mut values_ = vec![];
+    for (i, member) in record.members.iter().enumerate() {
+        let name = names::flag_member(&member.name);
+        let value_token = Literal::usize_unsuffixed(1 << i);
+        names_.push(name);
+        values_.push(value_token);
+    }
+
+    quote! {
+        wiggle::bitflags::bitflags! {
+            #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+            pub struct #ident: #repr {
+                #(const #names_ = #values_;)*
+            }
+        }
+
+        impl ::std::fmt::Display for #ident {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                f.write_str(stringify!(#ident))?;
+                f.write_str("(")?;
+                ::std::fmt::Debug::fmt(self, f)?;
+                f.write_str(" (0x")?;
+                ::std::fmt::LowerHex::fmt(&self.bits(), f)?;
+                f.write_str("))")?;
+                Ok(())
+            }
+        }
+
+        impl TryFrom<#repr> for #ident {
+            type Error = wiggle::GuestError;
+            #[inline]
+            fn try_from(value: #repr) -> Result<Self, wiggle::GuestError> {
+                #ident::from_bits(value)
+                    .ok_or(wiggle::GuestError::InvalidFlagValue(stringify!(#ident)))
+            }
+        }
+
+        impl TryFrom<#abi_repr> for #ident {
+            type Error = wiggle::GuestError;
+            #[inline]
+            fn try_from(value: #abi_repr) -> Result<Self, wiggle::GuestError> {
+                #ident::try_from(#repr::try_from(value)?)
+            }
+        }
+
+        impl From<#ident> for #repr {
+            #[inline]
+            fn from(e: #ident) -> #repr {
+                e.bits()
+            }
+        }
+
+        impl wiggle::GuestType for #ident {
+            #[inline]
+            fn guest_size() -> u32 {
+                #repr::guest_size()
+            }
+
+            #[inline]
+            fn guest_align() -> usize {
+                #repr::guest_align()
+            }
+
+            fn read(mem: &wiggle::GuestMemory, location: wiggle::GuestPtr<#ident>) -> Result<#ident, wiggle::GuestError> {
+                use std::convert::TryFrom;
+                let reprval = #repr::read(mem, location.cast())?;
+                let value = #ident::try_from(reprval)?;
+                Ok(value)
+            }
+
+            fn write(mem: &mut wiggle::GuestMemory, location: wiggle::GuestPtr<#ident>, val: Self) -> Result<(), wiggle::GuestError> {
+                let val: #repr = #repr::from(val);
+                #repr::write(mem, location.cast(), val)
+            }
+        }
+    }
+}

data/ext/cargo-vendor/wiggle-generate-22.0.0/src/types/handle.rs

@@ -0,0 +1,84 @@
+use crate::names;
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use witx::Layout;
+
+pub(super) fn define_handle(name: &witx::Id, h: &witx::HandleDatatype) -> TokenStream {
+    let ident = names::type_(name);
+    let size = h.mem_size_align().size as u32;
+    let align = h.mem_size_align().align;
+    quote! {
+        #[repr(transparent)]
+        #[derive(Copy, Clone, Debug, ::std::hash::Hash, Eq, PartialEq)]
+        pub struct #ident(u32);
+
+        impl #ident {
+            #[inline]
+            pub unsafe fn inner(&self) -> u32 {
+                self.0
+            }
+        }
+
+        impl From<#ident> for u32 {
+            #[inline]
+            fn from(e: #ident) -> u32 {
+                e.0
+            }
+        }
+
+        impl From<#ident> for i32 {
+            #[inline]
+            fn from(e: #ident) -> i32 {
+                e.0 as i32
+            }
+        }
+
+        impl From<u32> for #ident {
+            #[inline]
+            fn from(e: u32) -> #ident {
+                #ident(e)
+            }
+        }
+        impl From<i32> for #ident {
+            #[inline]
+            fn from(e: i32) -> #ident {
+                #ident(e as u32)
+            }
+        }
+
+        impl ::std::fmt::Display for #ident {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                write!(f, "{}({})", stringify!(#ident), self.0)
+            }
+        }
+
+        impl wiggle::GuestType for #ident {
+            #[inline]
+            fn guest_size() -> u32 {
+                #size
+            }
+
+            #[inline]
+            fn guest_align() -> usize {
+                #align
+            }
+
+            #[inline]
+            fn read(mem: &wiggle::GuestMemory, location: wiggle::GuestPtr<#ident>) -> Result<#ident, wiggle::GuestError> {
+                Ok(#ident(u32::read(mem, location.cast())?))
+            }
+
+            #[inline]
+            fn write(mem: &mut wiggle::GuestMemory, location: wiggle::GuestPtr<Self>, val: Self) -> Result<(), wiggle::GuestError> {
+                u32::write(mem, location.cast(), val.0)
+            }
+        }
+    }
+}
+
+impl super::WiggleType for witx::HandleDatatype {
+    fn impls_display(&self) -> bool {
+        true
+    }
+}

data/ext/cargo-vendor/wiggle-generate-22.0.0/src/types/mod.rs

@@ -0,0 +1,129 @@
+// mod r#enum;
+mod error;
+mod flags;
+mod handle;
+mod record;
+mod variant;
+
+use crate::codegen_settings::ErrorType;
+use crate::lifetimes::LifetimeExt;
+use crate::names;
+
+use proc_macro2::TokenStream;
+use quote::quote;
+
+pub fn define_datatype(namedtype: &witx::NamedType, error: Option<&ErrorType>) -> TokenStream {
+    match &namedtype.tref {
+        witx::TypeRef::Name(alias_to) => define_alias(&namedtype.name, &alias_to),
+        witx::TypeRef::Value(v) => match &**v {
+            witx::Type::Record(r) => match r.bitflags_repr() {
+                Some(repr) => flags::define_flags(&namedtype.name, repr, &r),
+                None => record::define_struct(&namedtype.name, &r),
+            },
+            witx::Type::Variant(v) => match error {
+                Some(ErrorType::Generated(error)) => {
+                    let d = variant::define_variant(&namedtype.name, &v, true);
+                    let e = error::define_error(&namedtype.name, &v, error);
+                    quote!( #d #e )
+                }
+                _ => variant::define_variant(&namedtype.name, &v, false),
+            },
+            witx::Type::Handle(h) => handle::define_handle(&namedtype.name, &h),
+            witx::Type::Builtin(b) => define_builtin(&namedtype.name, *b),
+            witx::Type::Pointer(p) => {
+                define_witx_pointer(&namedtype.name, quote!(wiggle::GuestPtr), p)
+            }
+            witx::Type::ConstPointer(p) => {
+                define_witx_pointer(&namedtype.name, quote!(wiggle::GuestPtr), p)
+            }
+            witx::Type::List(arr) => define_witx_list(&namedtype.name, &arr),
+        },
+    }
+}
+
+fn define_alias(name: &witx::Id, to: &witx::NamedType) -> TokenStream {
+    let ident = names::type_(name);
+    let rhs = names::type_(&to.name);
+    if to.tref.needs_lifetime() {
+        quote!(pub type #ident<'a> = #rhs<'a>;)
+    } else {
+        quote!(pub type #ident = #rhs;)
+    }
+}
+
+fn define_builtin(name: &witx::Id, builtin: witx::BuiltinType) -> TokenStream {
+    let ident = names::type_(name);
+    let built = names::builtin_type(builtin);
+    quote!(pub type #ident = #built;)
+}
+
+fn define_witx_pointer(
+    name: &witx::Id,
+    pointer_type: TokenStream,
+    pointee: &witx::TypeRef,
+) -> TokenStream {
+    let ident = names::type_(name);
+    let pointee_type = names::type_ref(pointee, quote!('a));
+
+    quote!(pub type #ident<'a> = #pointer_type<'a, #pointee_type>;)
+}
+
+fn define_witx_list(name: &witx::Id, arr_raw: &witx::TypeRef) -> TokenStream {
+    let ident = names::type_(name);
+    let pointee_type = names::type_ref(arr_raw, quote!());
+    quote!(pub type #ident = wiggle::GuestPtr<[#pointee_type]>;)
+}
+
+pub fn int_repr_tokens(int_repr: witx::IntRepr) -> TokenStream {
+    match int_repr {
+        witx::IntRepr::U8 => quote!(u8),
+        witx::IntRepr::U16 => quote!(u16),
+        witx::IntRepr::U32 => quote!(u32),
+        witx::IntRepr::U64 => quote!(u64),
+    }
+}
+
+pub trait WiggleType {
+    fn impls_display(&self) -> bool;
+}
+
+impl WiggleType for witx::TypeRef {
+    fn impls_display(&self) -> bool {
+        match self {
+            witx::TypeRef::Name(alias_to) => (&*alias_to).impls_display(),
+            witx::TypeRef::Value(v) => (&*v).impls_display(),
+        }
+    }
+}
+
+impl WiggleType for witx::NamedType {
+    fn impls_display(&self) -> bool {
+        self.tref.impls_display()
+    }
+}
+
+impl WiggleType for witx::Type {
+    fn impls_display(&self) -> bool {
+        match self {
+            witx::Type::Record(x) => x.impls_display(),
+            witx::Type::Variant(x) => x.impls_display(),
+            witx::Type::Handle(x) => x.impls_display(),
+            witx::Type::Builtin(x) => x.impls_display(),
+            witx::Type::Pointer { .. }
+            | witx::Type::ConstPointer { .. }
+            | witx::Type::List { .. } => false,
+        }
+    }
+}
+
+impl WiggleType for witx::BuiltinType {
+    fn impls_display(&self) -> bool {
+        true
+    }
+}
+
+impl WiggleType for witx::InterfaceFuncParam {
+    fn impls_display(&self) -> bool {
+        self.tref.impls_display()
+    }
+}