code_ownership 2.2.0 → 2.2.1

data/ext/cargo-vendor/{bindgen-0.69.5 → bindgen-0.72.1}/codegen/helpers.rs

@@ -1,5 +1,7 @@
 //! 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;
 
@@ -17,7 +19,6 @@ pub(crate) mod attributes {
     pub(crate) fn repr_list(which_ones: &[&str]) -> TokenStream {
         let which_ones = which_ones
             .iter()
-            .cloned()
             .map(|one| TokenStream::from_str(one).expect("repr to be valid"));
         quote! {
             #[repr( #( #which_ones ),* )]
@@ -27,7 +28,6 @@ pub(crate) mod attributes {
     pub(crate) fn derives(which_ones: &[&str]) -> TokenStream {
         let which_ones = which_ones
             .iter()
-            .cloned()
             .map(|one| TokenStream::from_str(one).expect("derive to be valid"));
         quote! {
             #[derive( #( #which_ones ),* )]
@@ -52,7 +52,7 @@ pub(crate) mod attributes {
         }
     }
 
-    pub(crate) fn doc(comment: String) -> TokenStream {
+    pub(crate) fn doc(comment: &str) -> TokenStream {
         if comment.is_empty() {
             quote!()
         } else {
@@ -66,7 +66,7 @@ pub(crate) mod attributes {
         let name: Cow<'_, str> = if MANGLE {
             name.into()
         } else {
-            format!("\u{1}{}", name).into()
+            format!("\u{1}{name}").into()
         };
 
         quote! {
@@ -75,44 +75,57 @@ pub(crate) mod attributes {
     }
 }
 
-/// Generates a proper type for a field or type with a given `Layout`, that is,
-/// a type with the correct size and alignment restrictions.
-pub(crate) fn blob(ctx: &BindgenContext, layout: Layout) -> syn::Type {
+/// 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 = match opaque.known_rust_type_for_array(ctx) {
-        Some(ty) => ty,
-        None => {
-            warn!("Found unknown alignment on code generation!");
-            syn::parse_quote! { u8 }
-        }
-    };
+    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(ctx).unwrap_or(layout.size);
+    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(
-    ctx: &BindgenContext,
-    layout: Layout,
-) -> Option<syn::Type> {
-    Layout::known_type_for_size(ctx, layout.size)
+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 ty = syn::parse_quote! { __BindgenBitfieldUnit<[u8; #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 };
@@ -126,7 +139,8 @@ pub(crate) mod ast_ty {
     use crate::ir::function::FunctionSig;
     use crate::ir::layout::Layout;
     use crate::ir::ty::{FloatKind, IntKind};
-    use proc_macro2::{self, TokenStream};
+    use crate::RustTarget;
+    use proc_macro2::TokenStream;
     use std::str::FromStr;
 
     pub(crate) fn c_void(ctx: &BindgenContext) -> syn::Type {
@@ -137,9 +151,7 @@ pub(crate) mod ast_ty {
                 syn::parse_quote! { #prefix::c_void }
             }
             None => {
-                if ctx.options().use_core &&
-                    ctx.options().rust_features.core_ffi_c_void
-                {
+                if ctx.options().use_core {
                     syn::parse_quote! { ::core::ffi::c_void }
                 } else {
                     syn::parse_quote! { ::std::os::raw::c_void }
@@ -175,6 +187,12 @@ pub(crate) mod ast_ty {
         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"),
@@ -188,7 +206,7 @@ pub(crate) mod ast_ty {
             IntKind::WChar => {
                 let layout =
                     layout.expect("Couldn't compute wchar_t's layout?");
-                Layout::known_type_for_size(ctx, layout.size)
+                Layout::known_type_for_size(layout.size)
                     .expect("Non-representable wchar_t?")
             }
 
@@ -204,7 +222,7 @@ pub(crate) mod ast_ty {
                 syn::parse_str(name).expect("Invalid integer type.")
             }
             IntKind::U128 => {
-                if ctx.options().rust_features.i128_and_u128 {
+                if true {
                     syn::parse_quote! { u128 }
                 } else {
                     // Best effort thing, but wrong alignment
@@ -213,7 +231,7 @@ pub(crate) mod ast_ty {
                 }
             }
             IntKind::I128 => {
-                if ctx.options().rust_features.i128_and_u128 {
+                if true {
                     syn::parse_quote! { i128 }
                 } else {
                     syn::parse_quote! { [u64; 2] }
@@ -246,28 +264,25 @@ pub(crate) mod ast_ty {
             (FloatKind::Float, false) => raw_type(ctx, "c_float"),
             (FloatKind::Double, false) => raw_type(ctx, "c_double"),
             (FloatKind::LongDouble, _) => {
-                match layout {
-                    Some(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(ctx, layout)
-                                .unwrap_or(syn::parse_quote! { f64 }),
-                        }
-                    }
-                    None => {
-                        debug_assert!(
-                            false,
-                            "How didn't we know the layout for a primitive type?"
-                        );
-                        syn::parse_quote! { f64 }
+                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 ctx.options().rust_features.i128_and_u128 {
+                if true {
                     syn::parse_quote! { u128 }
                 } else {
                     syn::parse_quote! { [u64; 2] }
@@ -307,26 +322,54 @@ pub(crate) mod ast_ty {
         }
 
         let prefix = ctx.trait_prefix();
+        let rust_target = ctx.options().rust_target;
 
         if f.is_nan() {
-            return Ok(quote! {
-                ::#prefix::f64::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() {
-            return Ok(if f.is_sign_positive() {
-                quote! {
-                    ::#prefix::f64::INFINITY
+            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 {
-                quote! {
-                    ::#prefix::f64::NEG_INFINITY
+                // 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);
+        warn!("Unknown non-finite float number: {f:?}");
         Err(())
     }
 
@@ -338,17 +381,14 @@ pub(crate) mod ast_ty {
         signature
             .argument_types()
             .iter()
-            .map(|&(ref name, _ty)| match *name {
-                Some(ref name) => {
-                    let name = ctx.rust_ident(name);
-                    quote! { #name }
-                }
-                None => {
+            .map(|&(ref name, _ty)| {
+                let name = if let Some(ref name) = *name {
+                    ctx.rust_ident(name)
+                } else {
                     unnamed_arguments += 1;
-                    let name =
-                        ctx.rust_ident(format!("arg{}", unnamed_arguments));
-                    quote! { #name }
-                }
+                    ctx.rust_ident(format!("arg{unnamed_arguments}"))
+                };
+                quote! { #name }
             })
             .collect()
     }

data/ext/cargo-vendor/{bindgen-0.69.5 → bindgen-0.72.1}/codegen/impl_debug.rs

@@ -2,6 +2,7 @@ use crate::ir::comp::{BitfieldUnit, CompKind, Field, FieldData, FieldMethods};
 use crate::ir::context::BindgenContext;
 use crate::ir::item::{HasTypeParamInArray, IsOpaque, Item, ItemCanonicalName};
 use crate::ir::ty::{TypeKind, RUST_DERIVE_IN_ARRAY_LIMIT};
+use std::fmt::Write as _;
 
 pub(crate) fn gen_debug_impl(
     ctx: &BindgenContext,
@@ -10,7 +11,7 @@ pub(crate) fn gen_debug_impl(
     kind: CompKind,
 ) -> proc_macro2::TokenStream {
     let struct_name = item.canonical_name(ctx);
-    let mut format_string = format!("{} {{{{ ", struct_name);
+    let mut format_string = format!("{struct_name} {{{{ ");
     let mut tokens = vec![];
 
     if item.is_opaque(ctx, &()) {
@@ -64,7 +65,7 @@ pub(crate) trait ImplDebug<'a> {
     ) -> Option<(String, Vec<proc_macro2::TokenStream>)>;
 }
 
-impl<'a> ImplDebug<'a> for FieldData {
+impl ImplDebug<'_> for FieldData {
     type Extra = ();
 
     fn impl_debug(
@@ -80,7 +81,7 @@ impl<'a> ImplDebug<'a> for FieldData {
     }
 }
 
-impl<'a> ImplDebug<'a> for BitfieldUnit {
+impl ImplDebug<'_> for BitfieldUnit {
     type Extra = ();
 
     fn impl_debug(
@@ -96,7 +97,7 @@ impl<'a> ImplDebug<'a> for BitfieldUnit {
             }
 
             if let Some(bitfield_name) = bitfield.name() {
-                format_string.push_str(&format!("{} : {{:?}}", bitfield_name));
+                let _ = write!(format_string, "{bitfield_name} : {{:?}}");
                 let getter_name = bitfield.getter_name();
                 let name_ident = ctx.rust_ident_raw(getter_name);
                 tokens.push(quote! {
@@ -125,19 +126,14 @@ impl<'a> ImplDebug<'a> for Item {
             return None;
         }
 
-        let ty = match self.as_type() {
-            Some(ty) => ty,
-            None => {
-                return None;
-            }
-        };
+        let ty = self.as_type()?;
 
         fn debug_print(
             name: &str,
-            name_ident: proc_macro2::TokenStream,
+            name_ident: &proc_macro2::TokenStream,
         ) -> Option<(String, Vec<proc_macro2::TokenStream>)> {
             Some((
-                format!("{}: {{:?}}", name),
+                format!("{name}: {{:?}}"),
                 vec![quote! {
                     self.#name_ident
                 }],
@@ -158,48 +154,50 @@ impl<'a> ImplDebug<'a> for Item {
             TypeKind::ObjCInterface(..) |
             TypeKind::ObjCId |
             TypeKind::Comp(..) |
-            TypeKind::ObjCSel => debug_print(name, quote! { #name_ident }),
+            TypeKind::ObjCSel => debug_print(name, &quote! { #name_ident }),
 
             TypeKind::TemplateInstantiation(ref inst) => {
                 if inst.is_opaque(ctx, self) {
-                    Some((format!("{}: opaque", name), vec![]))
+                    Some((format!("{name}: opaque"), vec![]))
                 } else {
-                    debug_print(name, quote! { #name_ident })
+                    debug_print(name, &quote! { #name_ident })
                 }
             }
 
             // The generic is not required to implement Debug, so we can not debug print that type
             TypeKind::TypeParam => {
-                Some((format!("{}: Non-debuggable generic", name), vec![]))
+                Some((format!("{name}: Non-debuggable generic"), vec![]))
             }
 
             TypeKind::Array(_, len) => {
                 // Generics are not required to implement Debug
                 if self.has_type_param_in_array(ctx) {
-                    Some((
-                        format!("{}: Array with length {}", name, len),
-                        vec![],
-                    ))
+                    Some((format!("{name}: Array with length {len}"), vec![]))
                 } else if len < RUST_DERIVE_IN_ARRAY_LIMIT ||
                     ctx.options().rust_features().larger_arrays
                 {
                     // The simple case
-                    debug_print(name, quote! { #name_ident })
+                    debug_print(name, &quote! { #name_ident })
                 } else if ctx.options().use_core {
                     // There is no String in core; reducing field visibility to avoid breaking
                     // no_std setups.
-                    Some((format!("{}: [...]", name), vec![]))
+                    Some((format!("{name}: [...]"), vec![]))
                 } else {
                     // Let's implement our own print function
                     Some((
-                        format!("{}: [{{}}]", name),
-                        vec![quote! {
-                            self.#name_ident
-                                .iter()
-                                .enumerate()
-                                .map(|(i, v)| format!("{}{:?}", if i > 0 { ", " } else { "" }, v))
-                                .collect::<String>()
-                        }],
+                        format!("{name}: [{{}}]"),
+                        vec![quote! {{
+                            use std::fmt::Write as _;
+                            let mut output = String::new();
+                            let mut iter = self.#name_ident.iter();
+                            if let Some(value) = iter.next() {
+                                let _ = write!(output, "{value:?}");
+                                for value in iter {
+                                    let _ = write!(output, ", {value:?}");
+                                }
+                            }
+                            output
+                        }}],
                     ))
                 }
             }
@@ -207,11 +205,11 @@ impl<'a> ImplDebug<'a> for Item {
                 if ctx.options().use_core {
                     // There is no format! in core; reducing field visibility to avoid breaking
                     // no_std setups.
-                    Some((format!("{}(...)", name), vec![]))
+                    Some((format!("{name}(...)"), vec![]))
                 } else {
                     let self_ids = 0..len;
                     Some((
-                        format!("{}({{}})", name),
+                        format!("{name}({{}})"),
                         vec![quote! {
                             #(format!("{:?}", self.#self_ids)),*
                         }],
@@ -233,9 +231,9 @@ impl<'a> ImplDebug<'a> for Item {
                     TypeKind::Function(ref sig)
                         if !sig.function_pointers_can_derive() =>
                     {
-                        Some((format!("{}: FunctionPointer", name), vec![]))
+                        Some((format!("{name}: FunctionPointer"), vec![]))
                     }
-                    _ => debug_print(name, quote! { #name_ident }),
+                    _ => debug_print(name, &quote! { #name_ident }),
                 }
             }
 

data/ext/cargo-vendor/{bindgen-0.69.5 → bindgen-0.72.1}/codegen/impl_partialeq.rs

@@ -23,7 +23,7 @@ pub(crate) fn gen_partialeq_impl(
             &self.bindgen_union_field[..] == &other.bindgen_union_field[..]
         });
     } else {
-        for base in comp_info.base_members().iter() {
+        for base in comp_info.base_members() {
             if !base.requires_storage(ctx) {
                 continue;
             }
@@ -76,7 +76,7 @@ fn gen_field(
     name: &str,
 ) -> proc_macro2::TokenStream {
     fn quote_equals(
-        name_ident: proc_macro2::Ident,
+        name_ident: &proc_macro2::Ident,
     ) -> proc_macro2::TokenStream {
         quote! { self.#name_ident == other.#name_ident }
     }
@@ -100,7 +100,7 @@ fn gen_field(
         TypeKind::Comp(..) |
         TypeKind::Pointer(_) |
         TypeKind::Function(..) |
-        TypeKind::Opaque => quote_equals(name_ident),
+        TypeKind::Opaque => quote_equals(&name_ident),
 
         TypeKind::TemplateInstantiation(ref inst) => {
             if inst.is_opaque(ctx, ty_item) {
@@ -108,7 +108,7 @@ fn gen_field(
                     &self. #name_ident [..] == &other. #name_ident [..]
                 }
             } else {
-                quote_equals(name_ident)
+                quote_equals(&name_ident)
             }
         }
 
@@ -116,7 +116,7 @@ fn gen_field(
             if len <= RUST_DERIVE_IN_ARRAY_LIMIT ||
                 ctx.options().rust_features().larger_arrays
             {
-                quote_equals(name_ident)
+                quote_equals(&name_ident)
             } else {
                 quote! {
                     &self. #name_ident [..] == &other. #name_ident [..]