wasmtime 21.0.1 → 22.0.0

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

@@ -1,129 +0,0 @@
-// 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!('a));
-    quote!(pub type #ident<'a> = wiggle::GuestPtr<'a, [#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()
-    }
-}

data/ext/cargo-vendor/wiggle-generate-21.0.1/src/types/record.rs

@@ -1,132 +0,0 @@
-use crate::lifetimes::{anon_lifetime, LifetimeExt};
-use crate::names;
-
-use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-use witx::Layout;
-
-pub(super) fn define_struct(name: &witx::Id, s: &witx::RecordDatatype) -> TokenStream {
-    let ident = names::type_(name);
-    let size = s.mem_size_align().size as u32;
-    let align = s.mem_size_align().align;
-
-    let member_names = s.members.iter().map(|m| names::struct_member(&m.name));
-    let member_decls = s.members.iter().map(|m| {
-        let name = names::struct_member(&m.name);
-        let type_ = match &m.tref {
-            witx::TypeRef::Name(nt) => {
-                let tt = names::type_(&nt.name);
-                if m.tref.needs_lifetime() {
-                    quote!(#tt<'a>)
-                } else {
-                    quote!(#tt)
-                }
-            }
-            witx::TypeRef::Value(ty) => match &**ty {
-                witx::Type::Builtin(builtin) => names::builtin_type(*builtin),
-                witx::Type::Pointer(pointee) | witx::Type::ConstPointer(pointee) => {
-                    let pointee_type = names::type_ref(&pointee, quote!('a));
-                    quote!(wiggle::GuestPtr<'a, #pointee_type>)
-                }
-                _ => unimplemented!("other anonymous struct members: {:?}", m.tref),
-            },
-        };
-        quote!(pub #name: #type_)
-    });
-
-    let member_offsets = s.member_layout().into_iter().map(|ml| {
-        let name = names::struct_member(&ml.member.name);
-        let offset = ml.offset as u32;
-        let method_name = format_ident!("offset_of_{}", name);
-        quote! {
-            pub const fn #method_name () -> u32 {
-                #offset
-            }
-        }
-    });
-
-    let member_reads = s.member_layout().into_iter().map(|ml| {
-        let name = names::struct_member(&ml.member.name);
-        let offset = ml.offset as u32;
-        let location = quote!(location.cast::<u8>().add(#offset)?.cast());
-        match &ml.member.tref {
-            witx::TypeRef::Name(nt) => {
-                let type_ = names::type_(&nt.name);
-                quote! {
-                    let #name = <#type_ as wiggle::GuestType>::read(&#location)?;
-                }
-            }
-            witx::TypeRef::Value(ty) => match &**ty {
-                witx::Type::Builtin(builtin) => {
-                    let type_ = names::builtin_type(*builtin);
-                    quote! {
-                        let #name = <#type_ as wiggle::GuestType>::read(&#location)?;
-                    }
-                }
-                witx::Type::Pointer(pointee) | witx::Type::ConstPointer(pointee) => {
-                    let pointee_type = names::type_ref(&pointee, anon_lifetime());
-                    quote! {
-                        let #name = <wiggle::GuestPtr::<#pointee_type> as wiggle::GuestType>::read(&#location)?;
-                    }
-                }
-                _ => unimplemented!("other anonymous struct members: {:?}", ty),
-            },
-        }
-    });
-
-    let member_writes = s.member_layout().into_iter().map(|ml| {
-        let name = names::struct_member(&ml.member.name);
-        let offset = ml.offset as u32;
-        quote! {
-            wiggle::GuestType::write(
-                &location.cast::<u8>().add(#offset)?.cast(),
-                val.#name,
-            )?;
-        }
-    });
-
-    let (struct_lifetime, extra_derive) = if s.needs_lifetime() {
-        (quote!(<'a>), quote!())
-    } else {
-        (quote!(), quote!(, PartialEq))
-    };
-
-    quote! {
-        #[derive(Clone, Debug #extra_derive)]
-        pub struct #ident #struct_lifetime {
-            #(#member_decls),*
-        }
-
-        impl #struct_lifetime #ident #struct_lifetime {
-            #(#member_offsets)*
-        }
-
-        impl<'a> wiggle::GuestType<'a> for #ident #struct_lifetime {
-            #[inline]
-            fn guest_size() -> u32 {
-                #size
-            }
-
-            #[inline]
-            fn guest_align() -> usize {
-                #align
-            }
-
-            fn read(location: &wiggle::GuestPtr<'a, Self>) -> Result<Self, wiggle::GuestError> {
-                #(#member_reads)*
-                Ok(#ident { #(#member_names),* })
-            }
-
-            fn write(location: &wiggle::GuestPtr<'_, Self>, val: Self) -> Result<(), wiggle::GuestError> {
-                #(#member_writes)*
-                Ok(())
-            }
-        }
-    }
-}
-
-impl super::WiggleType for witx::RecordDatatype {
-    fn impls_display(&self) -> bool {
-        false
-    }
-}

data/ext/cargo-vendor/wiggle-generate-21.0.1/src/types/variant.rs

@@ -1,191 +0,0 @@
-use crate::lifetimes::LifetimeExt;
-use crate::names;
-
-use proc_macro2::{Literal, TokenStream};
-use quote::quote;
-use witx::Layout;
-
-pub(super) fn define_variant(
-    name: &witx::Id,
-    v: &witx::Variant,
-    derive_std_error: bool,
-) -> TokenStream {
-    let ident = names::type_(name);
-    let size = v.mem_size_align().size as u32;
-    let align = v.mem_size_align().align;
-    let contents_offset = v.payload_offset() as u32;
-
-    let lifetime = quote!('a);
-    let tag_ty = super::int_repr_tokens(v.tag_repr);
-
-    let variants = v.cases.iter().map(|c| {
-        let var_name = names::enum_variant(&c.name);
-        if let Some(tref) = &c.tref {
-            let var_type = names::type_ref(&tref, lifetime.clone());
-            quote!(#var_name(#var_type))
-        } else {
-            quote!(#var_name)
-        }
-    });
-
-    let read_variant = v.cases.iter().enumerate().map(|(i, c)| {
-        let i = Literal::usize_unsuffixed(i);
-        let variantname = names::enum_variant(&c.name);
-        if let Some(tref) = &c.tref {
-            let varianttype = names::type_ref(tref, lifetime.clone());
-            quote! {
-                #i => {
-                    let variant_ptr = location.cast::<u8>().add(#contents_offset)?;
-                    let variant_val = <#varianttype as wiggle::GuestType>::read(&variant_ptr.cast())?;
-                    Ok(#ident::#variantname(variant_val))
-                }
-            }
-        } else {
-            quote! { #i => Ok(#ident::#variantname), }
-        }
-    });
-
-    let write_variant = v.cases.iter().enumerate().map(|(i, c)| {
-        let variantname = names::enum_variant(&c.name);
-        let write_tag = quote! {
-            location.cast().write(#i as #tag_ty)?;
-        };
-        if let Some(tref) = &c.tref {
-            let varianttype = names::type_ref(tref, lifetime.clone());
-            quote! {
-                #ident::#variantname(contents) => {
-                    #write_tag
-                    let variant_ptr = location.cast::<u8>().add(#contents_offset)?;
-                    <#varianttype as wiggle::GuestType>::write(&variant_ptr.cast(), contents)?;
-                }
-            }
-        } else {
-            quote! {
-                #ident::#variantname => {
-                    #write_tag
-                }
-            }
-        }
-    });
-
-    let mut extra_derive = quote!();
-    let enum_try_from = if v.cases.iter().all(|c| c.tref.is_none()) {
-        let tryfrom_repr_cases = v.cases.iter().enumerate().map(|(i, c)| {
-            let variant_name = names::enum_variant(&c.name);
-            let n = Literal::usize_unsuffixed(i);
-            quote!(#n => Ok(#ident::#variant_name))
-        });
-        let abi_ty = names::wasm_type(v.tag_repr.into());
-        extra_derive = quote!(, Copy);
-        quote! {
-            impl TryFrom<#tag_ty> for #ident {
-                type Error = wiggle::GuestError;
-                #[inline]
-                fn try_from(value: #tag_ty) -> Result<#ident, wiggle::GuestError> {
-                    match value {
-                        #(#tryfrom_repr_cases),*,
-                        _ => Err(wiggle::GuestError::InvalidEnumValue(stringify!(#ident))),
-                    }
-                }
-            }
-
-            impl TryFrom<#abi_ty> for #ident {
-                type Error = wiggle::GuestError;
-                #[inline]
-                fn try_from(value: #abi_ty) -> Result<#ident, wiggle::GuestError> {
-                    #ident::try_from(#tag_ty::try_from(value)?)
-                }
-            }
-        }
-    } else {
-        quote!()
-    };
-
-    let enum_from = if v.cases.iter().all(|c| c.tref.is_none()) {
-        let from_repr_cases = v.cases.iter().enumerate().map(|(i, c)| {
-            let variant_name = names::enum_variant(&c.name);
-            let n = Literal::usize_unsuffixed(i);
-            quote!(#ident::#variant_name => #n)
-        });
-        quote! {
-            impl From<#ident> for #tag_ty {
-                #[inline]
-                fn from(v: #ident) -> #tag_ty {
-                    match v {
-                        #(#from_repr_cases),*,
-                    }
-                }
-            }
-        }
-    } else {
-        quote!()
-    };
-
-    let (enum_lifetime, extra_derive) = if v.needs_lifetime() {
-        (quote!(<'a>), quote!())
-    } else {
-        (quote!(), quote!(, PartialEq #extra_derive))
-    };
-
-    let error_impls = if derive_std_error {
-        quote! {
-            impl std::fmt::Display for #ident {
-                fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                    write!(f, "{:?}", self)
-                }
-            }
-            impl std::error::Error for #ident {}
-        }
-    } else {
-        quote!()
-    };
-
-    quote! {
-        #[derive(Clone, Debug #extra_derive)]
-        pub enum #ident #enum_lifetime {
-            #(#variants),*
-        }
-        #error_impls
-
-        #enum_try_from
-        #enum_from
-
-        impl<'a> wiggle::GuestType<'a> for #ident #enum_lifetime {
-            #[inline]
-            fn guest_size() -> u32 {
-                #size
-            }
-
-            #[inline]
-            fn guest_align() -> usize {
-                #align
-            }
-
-            fn read(location: &wiggle::GuestPtr<'a, Self>)
-                -> Result<Self, wiggle::GuestError>
-            {
-                let tag = location.cast::<#tag_ty>().read()?;
-                match tag {
-                    #(#read_variant)*
-                    _ => Err(wiggle::GuestError::InvalidEnumValue(stringify!(#ident))),
-                }
-
-            }
-
-            fn write(location: &wiggle::GuestPtr<'_, Self>, val: Self)
-                -> Result<(), wiggle::GuestError>
-            {
-                match val {
-                    #(#write_variant)*
-                }
-                Ok(())
-            }
-        }
-    }
-}
-
-impl super::WiggleType for witx::Variant {
-    fn impls_display(&self) -> bool {
-        false
-    }
-}

data/ext/cargo-vendor/wiggle-generate-21.0.1/src/wasmtime.rs

@@ -1,170 +0,0 @@
-use crate::config::Asyncness;
-use crate::funcs::func_bounds;
-use crate::names;
-use crate::CodegenSettings;
-use proc_macro2::{Ident, Span, TokenStream};
-use quote::{format_ident, quote};
-use std::collections::HashSet;
-
-pub fn link_module(
-    module: &witx::Module,
-    target_path: Option<&syn::Path>,
-    settings: &CodegenSettings,
-) -> TokenStream {
-    let module_ident = names::module(&module.name);
-
-    let send_bound = if settings.async_.contains_async(module) {
-        quote! { + Send, T: Send }
-    } else {
-        quote! {}
-    };
-
-    let mut bodies = Vec::new();
-    let mut bounds = HashSet::new();
-    for f in module.funcs() {
-        let asyncness = settings.async_.get(module.name.as_str(), f.name.as_str());
-        bodies.push(generate_func(&module, &f, target_path, asyncness));
-        let bound = func_bounds(module, &f, settings);
-        for b in bound {
-            bounds.insert(b);
-        }
-    }
-
-    let ctx_bound = if let Some(target_path) = target_path {
-        let bounds = bounds
-            .into_iter()
-            .map(|b| quote!(#target_path::#module_ident::#b));
-        quote!( #(#bounds)+* #send_bound )
-    } else {
-        let bounds = bounds.into_iter();
-        quote!( #(#bounds)+* #send_bound )
-    };
-
-    let func_name = if target_path.is_none() {
-        format_ident!("add_to_linker")
-    } else {
-        format_ident!("add_{}_to_linker", module_ident)
-    };
-
-    let u = if settings.mutable {
-        quote!(&mut U)
-    } else {
-        quote!(&U)
-    };
-    quote! {
-        /// Adds all instance items to the specified `Linker`.
-        pub fn #func_name<T, U>(
-            linker: &mut wiggle::wasmtime_crate::Linker<T>,
-            get_cx: impl Fn(&mut T) -> #u + Send + Sync + Copy + 'static,
-        ) -> wiggle::anyhow::Result<()>
-            where
-                U: #ctx_bound #send_bound
-        {
-            #(#bodies)*
-            Ok(())
-        }
-    }
-}
-
-fn generate_func(
-    module: &witx::Module,
-    func: &witx::InterfaceFunc,
-    target_path: Option<&syn::Path>,
-    asyncness: Asyncness,
-) -> TokenStream {
-    let module_str = module.name.as_str();
-    let module_ident = names::module(&module.name);
-
-    let field_str = func.name.as_str();
-    let field_ident = names::func(&func.name);
-
-    let (params, results) = func.wasm_signature();
-
-    let arg_names = (0..params.len())
-        .map(|i| Ident::new(&format!("arg{}", i), Span::call_site()))
-        .collect::<Vec<_>>();
-    let arg_decls = params
-        .iter()
-        .enumerate()
-        .map(|(i, ty)| {
-            let name = &arg_names[i];
-            let wasm = names::wasm_type(*ty);
-            quote! { #name: #wasm }
-        })
-        .collect::<Vec<_>>();
-
-    let ret_ty = match results.len() {
-        0 => quote!(()),
-        1 => names::wasm_type(results[0]),
-        _ => unimplemented!(),
-    };
-
-    let await_ = if asyncness.is_sync() {
-        quote!()
-    } else {
-        quote!(.await)
-    };
-
-    let abi_func = if let Some(target_path) = target_path {
-        quote!( #target_path::#module_ident::#field_ident )
-    } else {
-        quote!( #field_ident )
-    };
-
-    let body = quote! {
-        let export = caller.get_export("memory");
-        let (mem, ctx) = match &export {
-            Some(wiggle::wasmtime_crate::Extern::Memory(m)) => {
-                let (mem, ctx) = m.data_and_store_mut(&mut caller);
-                let ctx = get_cx(ctx);
-                (wiggle::wasmtime::WasmtimeGuestMemory::new(mem), ctx)
-            }
-            Some(wiggle::wasmtime_crate::Extern::SharedMemory(m)) => {
-                let ctx = get_cx(caller.data_mut());
-                (wiggle::wasmtime::WasmtimeGuestMemory::shared(m.data()), ctx)
-            }
-            _ => wiggle::anyhow::bail!("missing required memory export"),
-        };
-        Ok(<#ret_ty>::from(#abi_func(ctx, &mem #(, #arg_names)*) #await_ ?))
-    };
-
-    match asyncness {
-        Asyncness::Async => {
-            let wrapper = format_ident!("func_wrap{}_async", params.len());
-            quote! {
-                linker.#wrapper(
-                    #module_str,
-                    #field_str,
-                    move |mut caller: wiggle::wasmtime_crate::Caller<'_, T> #(, #arg_decls)*| {
-                        Box::new(async move { #body })
-                    },
-                )?;
-            }
-        }
-
-        Asyncness::Blocking { block_with } => {
-            quote! {
-                linker.func_wrap(
-                    #module_str,
-                    #field_str,
-                    move |mut caller: wiggle::wasmtime_crate::Caller<'_, T> #(, #arg_decls)*| -> wiggle::anyhow::Result<#ret_ty> {
-                        let result = async { #body };
-                        #block_with(result)?
-                    },
-                )?;
-            }
-        }
-
-        Asyncness::Sync => {
-            quote! {
-                linker.func_wrap(
-                    #module_str,
-                    #field_str,
-                    move |mut caller: wiggle::wasmtime_crate::Caller<'_, T> #(, #arg_decls)*| -> wiggle::anyhow::Result<#ret_ty> {
-                        #body
-                    },
-                )?;
-            }
-        }
-    }
-}

data/ext/cargo-vendor/wiggle-macro-21.0.1/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"057a4a71cbfae81e517ef7d606a9655818f698cf0a14f5f370c185db4f08cb80","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","src/lib.rs":"f900ec4ff2b4b5f11d5ed5b15a1d521470fe94ecea2fbff3da1cb1b241df0d17"},"package":"0b47d2b4442ce93106dba5d1a9c59d5f85b5732878bb3d0598d3c93c0d01b16b"}

data/ext/cargo-vendor/wiggle-macro-21.0.1/Cargo.toml

@@ -1,55 +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-macro"
-version = "21.0.1"
-authors = [
-    "Pat Hickey <phickey@fastly.com>",
-    "Jakub Konka <kubkon@jakubkonka.com>",
-    "Alex Crichton <alex@alexcrichton.com>",
-]
-include = [
-    "src/**/*",
-    "LICENSE",
-]
-description = "Wiggle code generator"
-keywords = [
-    "webassembly",
-    "wasm",
-]
-categories = ["wasm"]
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-
-[lib]
-test = false
-doctest = false
-proc-macro = true
-
-[dependencies.proc-macro2]
-version = "1.0"
-
-[dependencies.quote]
-version = "1.0"
-
-[dependencies.syn]
-version = "2.0.25"
-features = ["full"]
-
-[dependencies.wiggle-generate]
-version = "=21.0.1"
-
-[dev-dependencies]
-
-[features]
-wiggle_metadata = []