code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/bindgen-0.72.1/codegen/dyngen.rs

@@ -0,0 +1,258 @@
+use crate::codegen;
+use crate::ir::context::BindgenContext;
+use crate::ir::function::ClangAbi;
+use proc_macro2::{Ident, TokenStream};
+
+/// Used to build the output tokens for dynamic bindings.
+#[derive(Default)]
+pub(crate) struct DynamicItems {
+    /// Tracks the tokens that will appears inside the library struct -- e.g.:
+    /// ```ignore
+    /// struct Lib {
+    ///    __library: ::libloading::Library,
+    ///    pub x: Result<unsafe extern ..., ::libloading::Error>, // <- tracks these
+    ///    ...
+    /// }
+    /// ```
+    struct_members: Vec<TokenStream>,
+
+    /// Tracks the tokens that will appear inside the library struct's implementation, e.g.:
+    ///
+    /// ```ignore
+    /// impl Lib {
+    ///     ...
+    ///     pub unsafe fn foo(&self, ...) { // <- tracks these
+    ///         ...
+    ///     }
+    /// }
+    /// ```
+    struct_implementation: Vec<TokenStream>,
+
+    /// Tracks the initialization of the fields inside the `::new` constructor of the library
+    /// struct, e.g.:
+    /// ```ignore
+    /// impl Lib {
+    ///
+    ///     pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    ///     where
+    ///         P: AsRef<::std::ffi::OsStr>,
+    ///     {
+    ///         ...
+    ///         let foo = __library.get(...) ...; // <- tracks these
+    ///         ...
+    ///     }
+    ///
+    ///     ...
+    /// }
+    /// ```
+    constructor_inits: Vec<TokenStream>,
+
+    /// Tracks the information that is passed to the library struct at the end of the `::new`
+    /// constructor, e.g.:
+    /// ```ignore
+    /// impl LibFoo {
+    ///     pub unsafe fn new<P>(path: P) -> Result<Self, ::libloading::Error>
+    ///     where
+    ///         P: AsRef<::std::ffi::OsStr>,
+    ///     {
+    ///         ...
+    ///         Ok(LibFoo {
+    ///             __library: __library,
+    ///             foo,
+    ///             bar, // <- tracks these
+    ///             ...
+    ///         })
+    ///     }
+    /// }
+    /// ```
+    init_fields: Vec<TokenStream>,
+}
+
+impl DynamicItems {
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn get_tokens(
+        &self,
+        lib_ident: &Ident,
+        ctx: &BindgenContext,
+    ) -> TokenStream {
+        let struct_members = &self.struct_members;
+        let constructor_inits = &self.constructor_inits;
+        let init_fields = &self.init_fields;
+        let struct_implementation = &self.struct_implementation;
+
+        let library_new = if ctx.options().wrap_unsafe_ops {
+            quote!(unsafe { ::libloading::Library::new(path) })
+        } else {
+            quote!(::libloading::Library::new(path))
+        };
+
+        let from_library = if ctx.options().wrap_unsafe_ops {
+            quote!(unsafe { Self::from_library(library) })
+        } else {
+            quote!(Self::from_library(library))
+        };
+
+        quote! {
+            pub struct #lib_ident {
+                __library: ::libloading::Library,
+                #(#struct_members)*
+            }
+
+            impl #lib_ident {
+                pub unsafe fn new<P>(
+                    path: P
+                ) -> Result<Self, ::libloading::Error>
+                where P: AsRef<::std::ffi::OsStr> {
+                    let library = #library_new?;
+                    #from_library
+                }
+
+                pub unsafe fn from_library<L>(
+                    library: L
+                ) -> Result<Self, ::libloading::Error>
+                where L: Into<::libloading::Library> {
+                    let __library = library.into();
+                    #( #constructor_inits )*
+                    Ok(#lib_ident {
+                        __library,
+                        #( #init_fields ),*
+                    })
+                }
+
+                #( #struct_implementation )*
+            }
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn push_func(
+        &mut self,
+        ident: &Ident,
+        symbol: &str,
+        abi: ClangAbi,
+        is_variadic: bool,
+        is_required: bool,
+        args: &[TokenStream],
+        args_identifiers: &[TokenStream],
+        ret: &TokenStream,
+        ret_ty: &TokenStream,
+        attributes: &[TokenStream],
+        ctx: &BindgenContext,
+    ) {
+        if !is_variadic {
+            assert_eq!(args.len(), args_identifiers.len());
+        }
+
+        let signature = quote! { unsafe extern #abi fn ( #( #args),* ) #ret };
+        let member = if is_required {
+            signature
+        } else {
+            quote! { Result<#signature, ::libloading::Error> }
+        };
+
+        self.struct_members.push(quote! {
+            pub #ident: #member,
+        });
+
+        // N.B: If the signature was required, it won't be wrapped in a Result<...>
+        //      and we can simply call it directly.
+        let fn_ = if is_required {
+            quote! { self.#ident }
+        } else {
+            quote! { self.#ident.as_ref().expect("Expected function, got error.") }
+        };
+        let call_body = if ctx.options().wrap_unsafe_ops {
+            quote!(unsafe { (#fn_)(#( #args_identifiers ),*) })
+        } else {
+            quote!((#fn_)(#( #args_identifiers ),*) )
+        };
+
+        // We can't implement variadic functions from C easily, so we allow to
+        // access the function pointer so that the user can call it just fine.
+        if !is_variadic {
+            self.struct_implementation.push(quote! {
+                #(#attributes)*
+                pub unsafe fn #ident ( &self, #( #args ),* ) #ret_ty {
+                    #call_body
+                }
+            });
+        }
+
+        // N.B: Unwrap the signature upon construction if it is required to be resolved.
+        let symbol_cstr =
+            codegen::helpers::ast_ty::cstr_expr(symbol.to_string());
+        let library_get = if ctx.options().wrap_unsafe_ops {
+            quote!(unsafe { __library.get(#symbol_cstr) })
+        } else {
+            quote!(__library.get(#symbol_cstr))
+        };
+
+        self.constructor_inits.push(if is_required {
+            quote! {
+                let #ident = #library_get.map(|sym| *sym)?;
+            }
+        } else {
+            quote! {
+                let #ident = #library_get.map(|sym| *sym);
+            }
+        });
+
+        self.init_fields.push(quote! {
+            #ident
+        });
+    }
+
+    pub fn push_var(
+        &mut self,
+        ident: &Ident,
+        symbol: &str,
+        ty: &TokenStream,
+        is_required: bool,
+        wrap_unsafe_ops: bool,
+    ) {
+        let member = if is_required {
+            quote! { *mut #ty }
+        } else {
+            quote! { Result<*mut #ty, ::libloading::Error> }
+        };
+
+        self.struct_members.push(quote! {
+            pub #ident: #member,
+        });
+
+        let deref = if is_required {
+            quote! { self.#ident }
+        } else {
+            quote! { *self.#ident.as_ref().expect("Expected variable, got error.") }
+        };
+        self.struct_implementation.push(quote! {
+            pub unsafe fn #ident (&self) -> *mut #ty {
+                #deref
+            }
+        });
+
+        let symbol_cstr =
+            codegen::helpers::ast_ty::cstr_expr(symbol.to_string());
+
+        let library_get = if wrap_unsafe_ops {
+            quote!(unsafe { __library.get::<*mut #ty>(#symbol_cstr) })
+        } else {
+            quote!(__library.get::<*mut #ty>(#symbol_cstr))
+        };
+
+        let qmark = if is_required { quote!(?) } else { quote!() };
+
+        let var_get = quote! {
+            let #ident = #library_get.map(|sym| *sym)#qmark;
+        };
+
+        self.constructor_inits.push(var_get);
+
+        self.init_fields.push(quote! {
+            #ident
+        });
+    }
+}

data/ext/cargo-vendor/bindgen-0.72.1/codegen/error.rs

@@ -0,0 +1,52 @@
+use std::error;
+use std::fmt;
+
+/// Errors that can occur during code generation.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum Error {
+    /// Tried to generate an opaque blob for a type that did not have a layout.
+    NoLayoutForOpaqueBlob,
+
+    /// Tried to instantiate an opaque template definition, or a template
+    /// definition that is too difficult for us to understand (like a partial
+    /// template specialization).
+    InstantiationOfOpaqueType,
+
+    /// Function ABI is not supported.
+    UnsupportedAbi(&'static str),
+
+    /// The pointer type size does not match the target's pointer size.
+    InvalidPointerSize {
+        ty_name: String,
+        ty_size: usize,
+        ptr_size: usize,
+    },
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Error::NoLayoutForOpaqueBlob => {
+                "Tried to generate an opaque blob, but had no layout.".fmt(f)
+            }
+            Error::InstantiationOfOpaqueType => {
+                "Instantiation of opaque template type or partial template specialization."
+                    .fmt(f)
+            }
+            Error::UnsupportedAbi(abi) => {
+                 write!(
+                    f,
+                    "{abi} ABI is not supported by the configured Rust target."
+                )
+            }
+            Error::InvalidPointerSize { ty_name, ty_size, ptr_size } => {
+                write!(f, "The {ty_name} pointer type has size {ty_size} but the current target's pointer size is {ptr_size}.")
+            }
+        }
+    }
+}
+
+impl error::Error for Error {}
+
+/// A `Result` of `T` or an error of `bindgen::codegen::error::Error`.
+pub(crate) type Result<T> = ::std::result::Result<T, Error>;

data/ext/cargo-vendor/bindgen-0.72.1/codegen/helpers.rs

@@ -0,0 +1,395 @@
+//! Helpers for code generation that don't need macro expansion.
+
+use proc_macro2::{Ident, Span};
+
+use crate::ir::context::BindgenContext;
+use crate::ir::layout::Layout;
+
+pub(crate) mod attributes {
+    use proc_macro2::{Ident, Span, TokenStream};
+    use std::{borrow::Cow, str::FromStr};
+
+    pub(crate) fn repr(which: &str) -> TokenStream {
+        let which = Ident::new(which, Span::call_site());
+        quote! {
+            #[repr( #which )]
+        }
+    }
+
+    pub(crate) fn repr_list(which_ones: &[&str]) -> TokenStream {
+        let which_ones = which_ones
+            .iter()
+            .map(|one| TokenStream::from_str(one).expect("repr to be valid"));
+        quote! {
+            #[repr( #( #which_ones ),* )]
+        }
+    }
+
+    pub(crate) fn derives(which_ones: &[&str]) -> TokenStream {
+        let which_ones = which_ones
+            .iter()
+            .map(|one| TokenStream::from_str(one).expect("derive to be valid"));
+        quote! {
+            #[derive( #( #which_ones ),* )]
+        }
+    }
+
+    pub(crate) fn inline() -> TokenStream {
+        quote! {
+            #[inline]
+        }
+    }
+
+    pub(crate) fn must_use() -> TokenStream {
+        quote! {
+            #[must_use]
+        }
+    }
+
+    pub(crate) fn non_exhaustive() -> TokenStream {
+        quote! {
+            #[non_exhaustive]
+        }
+    }
+
+    pub(crate) fn doc(comment: &str) -> TokenStream {
+        if comment.is_empty() {
+            quote!()
+        } else {
+            quote!(#[doc = #comment])
+        }
+    }
+
+    pub(crate) fn link_name<const MANGLE: bool>(name: &str) -> TokenStream {
+        // LLVM mangles the name by default but it's already mangled.
+        // Prefixing the name with \u{1} should tell LLVM to not mangle it.
+        let name: Cow<'_, str> = if MANGLE {
+            name.into()
+        } else {
+            format!("\u{1}{name}").into()
+        };
+
+        quote! {
+            #[link_name = #name]
+        }
+    }
+}
+
+/// The `ffi_safe` argument should be true if this is a type that the user might
+/// reasonably use, e.g. not struct padding, where the `__BindgenOpaqueArray` is
+/// just noise.
+/// TODO: Should this be `MaybeUninit`, since padding bytes are effectively
+/// uninitialized?
+pub(crate) fn blob(
+    ctx: &BindgenContext,
+    layout: Layout,
+    ffi_safe: bool,
+) -> syn::Type {
+    let opaque = layout.opaque();
+
+    // FIXME(emilio, #412): We fall back to byte alignment, but there are
+    // some things that legitimately are more than 8-byte aligned.
+    //
+    // Eventually we should be able to `unwrap` here, but...
+    let ty = opaque.known_rust_type_for_array().unwrap_or_else(|| {
+        warn!("Found unknown alignment on code generation!");
+        syn::parse_quote! { u8 }
+    });
+
+    let data_len = opaque.array_size().unwrap_or(layout.size);
+
+    if data_len == 1 {
+        ty
+    } else if ffi_safe && ctx.options().rust_features().min_const_generics {
+        ctx.generated_opaque_array();
+        if ctx.options().enable_cxx_namespaces {
+            syn::parse_quote! { root::__BindgenOpaqueArray<#ty, #data_len> }
+        } else {
+            syn::parse_quote! { __BindgenOpaqueArray<#ty, #data_len> }
+        }
+    } else {
+        // This is not FFI safe as an argument; the struct above is
+        // preferable.
+        syn::parse_quote! { [ #ty ; #data_len ] }
+    }
+}
+
+/// Integer type of the same size as the given `Layout`.
+pub(crate) fn integer_type(layout: Layout) -> Option<syn::Type> {
+    Layout::known_type_for_size(layout.size)
+}
+
+pub(crate) const BITFIELD_UNIT: &str = "__BindgenBitfieldUnit";
+
+/// Generates a bitfield allocation unit type for a type with the given `Layout`.
+pub(crate) fn bitfield_unit(ctx: &BindgenContext, layout: Layout) -> syn::Type {
+    let size = layout.size;
+    let bitfield_unit_name = Ident::new(BITFIELD_UNIT, Span::call_site());
+    let ty = syn::parse_quote! { #bitfield_unit_name<[u8; #size]> };
+
+    if ctx.options().enable_cxx_namespaces {
+        return syn::parse_quote! { root::#ty };
+    }
+
+    ty
+}
+
+pub(crate) mod ast_ty {
+    use crate::ir::context::BindgenContext;
+    use crate::ir::function::FunctionSig;
+    use crate::ir::layout::Layout;
+    use crate::ir::ty::{FloatKind, IntKind};
+    use crate::RustTarget;
+    use proc_macro2::TokenStream;
+    use std::str::FromStr;
+
+    pub(crate) fn c_void(ctx: &BindgenContext) -> syn::Type {
+        // ctypes_prefix takes precedence
+        match ctx.options().ctypes_prefix {
+            Some(ref prefix) => {
+                let prefix = TokenStream::from_str(prefix.as_str()).unwrap();
+                syn::parse_quote! { #prefix::c_void }
+            }
+            None => {
+                if ctx.options().use_core {
+                    syn::parse_quote! { ::core::ffi::c_void }
+                } else {
+                    syn::parse_quote! { ::std::os::raw::c_void }
+                }
+            }
+        }
+    }
+
+    pub(crate) fn raw_type(ctx: &BindgenContext, name: &str) -> syn::Type {
+        let ident = ctx.rust_ident_raw(name);
+        match ctx.options().ctypes_prefix {
+            Some(ref prefix) => {
+                let prefix = TokenStream::from_str(prefix.as_str()).unwrap();
+                syn::parse_quote! { #prefix::#ident }
+            }
+            None => {
+                if ctx.options().use_core &&
+                    ctx.options().rust_features().core_ffi_c
+                {
+                    syn::parse_quote! { ::core::ffi::#ident }
+                } else {
+                    syn::parse_quote! { ::std::os::raw::#ident }
+                }
+            }
+        }
+    }
+
+    pub(crate) fn int_kind_rust_type(
+        ctx: &BindgenContext,
+        ik: IntKind,
+        layout: Option<Layout>,
+    ) -> syn::Type {
+        match ik {
+            IntKind::Bool => syn::parse_quote! { bool },
+            IntKind::Char { .. } => raw_type(ctx, "c_char"),
+            // The following is used only when an unusual command-line
+            // argument is used. bindgen_cchar16_t is not a real type;
+            // but this allows downstream postprocessors to distinguish
+            // this case and do something special for C++ bindings
+            // containing the C++ type char16_t.
+            IntKind::Char16 => syn::parse_quote! { bindgen_cchar16_t },
+            IntKind::SChar => raw_type(ctx, "c_schar"),
+            IntKind::UChar => raw_type(ctx, "c_uchar"),
+            IntKind::Short => raw_type(ctx, "c_short"),
+            IntKind::UShort => raw_type(ctx, "c_ushort"),
+            IntKind::Int => raw_type(ctx, "c_int"),
+            IntKind::UInt => raw_type(ctx, "c_uint"),
+            IntKind::Long => raw_type(ctx, "c_long"),
+            IntKind::ULong => raw_type(ctx, "c_ulong"),
+            IntKind::LongLong => raw_type(ctx, "c_longlong"),
+            IntKind::ULongLong => raw_type(ctx, "c_ulonglong"),
+            IntKind::WChar => {
+                let layout =
+                    layout.expect("Couldn't compute wchar_t's layout?");
+                Layout::known_type_for_size(layout.size)
+                    .expect("Non-representable wchar_t?")
+            }
+
+            IntKind::I8 => syn::parse_quote! { i8 },
+            IntKind::U8 => syn::parse_quote! { u8 },
+            IntKind::I16 => syn::parse_quote! { i16 },
+            IntKind::U16 => syn::parse_quote! { u16 },
+            IntKind::I32 => syn::parse_quote! { i32 },
+            IntKind::U32 => syn::parse_quote! { u32 },
+            IntKind::I64 => syn::parse_quote! { i64 },
+            IntKind::U64 => syn::parse_quote! { u64 },
+            IntKind::Custom { name, .. } => {
+                syn::parse_str(name).expect("Invalid integer type.")
+            }
+            IntKind::U128 => {
+                if true {
+                    syn::parse_quote! { u128 }
+                } else {
+                    // Best effort thing, but wrong alignment
+                    // unfortunately.
+                    syn::parse_quote! { [u64; 2] }
+                }
+            }
+            IntKind::I128 => {
+                if true {
+                    syn::parse_quote! { i128 }
+                } else {
+                    syn::parse_quote! { [u64; 2] }
+                }
+            }
+        }
+    }
+
+    pub(crate) fn float_kind_rust_type(
+        ctx: &BindgenContext,
+        fk: FloatKind,
+        layout: Option<Layout>,
+    ) -> syn::Type {
+        // TODO: we probably should take the type layout into account more
+        // often?
+        //
+        // Also, maybe this one shouldn't be the default?
+        match (fk, ctx.options().convert_floats) {
+            (FloatKind::Float16, _) => {
+                // TODO: do f16 when rust lands it
+                ctx.generated_bindgen_float16();
+                if ctx.options().enable_cxx_namespaces {
+                    syn::parse_quote! { root::__BindgenFloat16 }
+                } else {
+                    syn::parse_quote! { __BindgenFloat16 }
+                }
+            }
+            (FloatKind::Float, true) => syn::parse_quote! { f32 },
+            (FloatKind::Double, true) => syn::parse_quote! { f64 },
+            (FloatKind::Float, false) => raw_type(ctx, "c_float"),
+            (FloatKind::Double, false) => raw_type(ctx, "c_double"),
+            (FloatKind::LongDouble, _) => {
+                if let Some(layout) = layout {
+                    match layout.size {
+                        4 => syn::parse_quote! { f32 },
+                        8 => syn::parse_quote! { f64 },
+                        // TODO(emilio): If rust ever gains f128 we should
+                        // use it here and below.
+                        _ => super::integer_type(layout)
+                            .unwrap_or(syn::parse_quote! { f64 }),
+                    }
+                } else {
+                    debug_assert!(
+                        false,
+                        "How didn't we know the layout for a primitive type?"
+                    );
+                    syn::parse_quote! { f64 }
+                }
+            }
+            (FloatKind::Float128, _) => {
+                if true {
+                    syn::parse_quote! { u128 }
+                } else {
+                    syn::parse_quote! { [u64; 2] }
+                }
+            }
+        }
+    }
+
+    pub(crate) fn int_expr(val: i64) -> TokenStream {
+        // Don't use quote! { #val } because that adds the type suffix.
+        let val = proc_macro2::Literal::i64_unsuffixed(val);
+        quote!(#val)
+    }
+
+    pub(crate) fn uint_expr(val: u64) -> TokenStream {
+        // Don't use quote! { #val } because that adds the type suffix.
+        let val = proc_macro2::Literal::u64_unsuffixed(val);
+        quote!(#val)
+    }
+
+    pub(crate) fn cstr_expr(mut string: String) -> TokenStream {
+        string.push('\0');
+        let b = proc_macro2::Literal::byte_string(string.as_bytes());
+        quote! {
+            #b
+        }
+    }
+
+    pub(crate) fn float_expr(
+        ctx: &BindgenContext,
+        f: f64,
+    ) -> Result<TokenStream, ()> {
+        if f.is_finite() {
+            let val = proc_macro2::Literal::f64_unsuffixed(f);
+
+            return Ok(quote!(#val));
+        }
+
+        let prefix = ctx.trait_prefix();
+        let rust_target = ctx.options().rust_target;
+
+        if f.is_nan() {
+            // FIXME: This should be done behind a `RustFeature` instead
+            #[allow(deprecated)]
+            let tokens = if rust_target >= RustTarget::Stable_1_43 {
+                quote! {
+                    f64::NAN
+                }
+            } else {
+                quote! {
+                    ::#prefix::f64::NAN
+                }
+            };
+            return Ok(tokens);
+        }
+
+        if f.is_infinite() {
+            let tokens = if f.is_sign_positive() {
+                // FIXME: This should be done behind a `RustFeature` instead
+                #[allow(deprecated)]
+                if rust_target >= RustTarget::Stable_1_43 {
+                    quote! {
+                        f64::INFINITY
+                    }
+                } else {
+                    quote! {
+                        ::#prefix::f64::INFINITY
+                    }
+                }
+            } else {
+                // FIXME: This should be done behind a `RustFeature` instead
+                #[allow(deprecated)]
+                // Negative infinity
+                if rust_target >= RustTarget::Stable_1_43 {
+                    quote! {
+                        f64::NEG_INFINITY
+                    }
+                } else {
+                    quote! {
+                        ::#prefix::f64::NEG_INFINITY
+                    }
+                }
+            };
+            return Ok(tokens);
+        }
+
+        warn!("Unknown non-finite float number: {f:?}");
+        Err(())
+    }
+
+    pub(crate) fn arguments_from_signature(
+        signature: &FunctionSig,
+        ctx: &BindgenContext,
+    ) -> Vec<TokenStream> {
+        let mut unnamed_arguments = 0;
+        signature
+            .argument_types()
+            .iter()
+            .map(|&(ref name, _ty)| {
+                let name = if let Some(ref name) = *name {
+                    ctx.rust_ident(name)
+                } else {
+                    unnamed_arguments += 1;
+                    ctx.rust_ident(format!("arg{unnamed_arguments}"))
+                };
+                quote! { #name }
+            })
+            .collect()
+    }
+}