code_ownership 2.2.0 → 2.2.1

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

@@ -4,7 +4,7 @@ use syn::{
 };
 
 pub(super) fn merge_extern_blocks(file: &mut File) {
-    Visitor.visit_file_mut(file)
+    Visitor.visit_file_mut(file);
 }
 
 struct Visitor;
@@ -12,14 +12,14 @@ struct Visitor;
 impl VisitMut for Visitor {
     fn visit_file_mut(&mut self, file: &mut File) {
         visit_items(&mut file.items);
-        visit_file_mut(self, file)
+        visit_file_mut(self, file);
     }
 
     fn visit_item_mod_mut(&mut self, item_mod: &mut ItemMod) {
         if let Some((_, ref mut items)) = item_mod.content {
             visit_items(items);
         }
-        visit_item_mod_mut(self, item_mod)
+        visit_item_mod_mut(self, item_mod);
     }
 }
 

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

@@ -4,7 +4,7 @@ use syn::{
 };
 
 pub(super) fn sort_semantically(file: &mut File) {
-    Visitor.visit_file_mut(file)
+    Visitor.visit_file_mut(file);
 }
 
 struct Visitor;
@@ -12,14 +12,14 @@ struct Visitor;
 impl VisitMut for Visitor {
     fn visit_file_mut(&mut self, file: &mut File) {
         visit_items(&mut file.items);
-        visit_file_mut(self, file)
+        visit_file_mut(self, file);
     }
 
     fn visit_item_mod_mut(&mut self, item_mod: &mut ItemMod) {
         if let Some((_, ref mut items)) = item_mod.content {
             visit_items(items);
         }
-        visit_item_mod_mut(self, item_mod)
+        visit_item_mod_mut(self, item_mod);
     }
 }
 

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

@@ -14,8 +14,7 @@ use super::{CodegenError, WrapAsVariadic};
 
 fn get_loc(item: &Item) -> String {
     item.location()
-        .map(|x| x.to_string())
-        .unwrap_or_else(|| "unknown".to_owned())
+        .map_or_else(|| "unknown".to_owned(), |x| x.to_string())
 }
 
 pub(super) trait CSerialize<'a> {
@@ -45,7 +44,7 @@ impl<'a> CSerialize<'a> for Item {
                 func.serialize(ctx, (self, extra), stack, writer)
             }
             kind => Err(CodegenError::Serialize {
-                msg: format!("Cannot serialize item kind {:?}", kind),
+                msg: format!("Cannot serialize item kind {kind:?}"),
                 loc: get_loc(self),
             }),
         }
@@ -72,16 +71,17 @@ impl<'a> CSerialize<'a> for Function {
             });
         }
 
-        let signature = match ctx.resolve_type(self.signature()).kind() {
-            TypeKind::Function(signature) => signature,
-            _ => unreachable!(),
+        let TypeKind::Function(signature) =
+            ctx.resolve_type(self.signature()).kind()
+        else {
+            unreachable!()
         };
 
         assert!(!signature.is_variadic());
 
         let name = self.name();
 
-        // Function argoments stored as `(name, type_id)` tuples.
+        // Function arguments stored as `(name, type_id)` tuples.
         let args = {
             let mut count = 0;
 
@@ -102,7 +102,7 @@ impl<'a> CSerialize<'a> for Function {
                     } else {
                         Some((
                             opt_name.unwrap_or_else(|| {
-                                let name = format!("arg_{}", count);
+                                let name = format!("arg_{count}");
                                 count += 1;
                                 name
                             }),
@@ -114,7 +114,7 @@ impl<'a> CSerialize<'a> for Function {
         };
 
         // The name used for the wrapper self.
-        let wrap_name = format!("{}{}", name, ctx.wrap_static_fns_suffix());
+        let wrap_name = format!("{name}{}", ctx.wrap_static_fns_suffix());
 
         // The function's return type
         let (ret_item, ret_ty) = {
@@ -131,15 +131,15 @@ impl<'a> CSerialize<'a> for Function {
         const INDENT: &str = "    ";
 
         // Write `wrap_name(args`.
-        write!(writer, " {}(", wrap_name)?;
+        write!(writer, " {wrap_name}(")?;
         serialize_args(&args, ctx, writer)?;
 
         if wrap_as_variadic.is_none() {
             // Write `) { name(` if the function returns void and `) { return name(` if it does not.
             if ret_ty.is_void() {
-                write!(writer, ") {{ {}(", name)?;
+                write!(writer, ") {{ {name}(")?;
             } else {
-                write!(writer, ") {{ return {}(", name)?;
+                write!(writer, ") {{ return {name}(")?;
             }
         } else {
             // Write `, ...) {`
@@ -165,7 +165,7 @@ impl<'a> CSerialize<'a> for Function {
             if !ret_ty.is_void() {
                 write!(writer, "ret = ")?;
             }
-            write!(writer, "{}(", name)?;
+            write!(writer, "{name}(")?;
         }
 
         // Get the arguments names and insert at the right place if necessary `ap`
@@ -179,7 +179,7 @@ impl<'a> CSerialize<'a> for Function {
 
         // Write `arg_names);`.
         serialize_sep(", ", args.iter(), ctx, writer, |name, _, buf| {
-            write!(buf, "{}", name).map_err(From::from)
+            write!(buf, "{name}").map_err(From::from)
         })?;
         #[rustfmt::skip]
         write!(writer, ");{}", if wrap_as_variadic.is_none() { " " } else { "\n" })?;
@@ -198,7 +198,7 @@ impl<'a> CSerialize<'a> for Function {
     }
 }
 
-impl<'a> CSerialize<'a> for TypeId {
+impl CSerialize<'_> for TypeId {
     type Extra = ();
 
     fn serialize<W: Write>(
@@ -228,13 +228,13 @@ impl<'a> CSerialize<'a> for Type {
                 if self.is_const() {
                     write!(writer, "const ")?;
                 }
-                write!(writer, "void")?
+                write!(writer, "void")?;
             }
             TypeKind::NullPtr => {
                 if self.is_const() {
                     write!(writer, "const ")?;
                 }
-                write!(writer, "nullptr_t")?
+                write!(writer, "nullptr_t")?;
             }
             TypeKind::Int(int_kind) => {
                 if self.is_const() {
@@ -257,8 +257,7 @@ impl<'a> CSerialize<'a> for Type {
                     int_kind => {
                         return Err(CodegenError::Serialize {
                             msg: format!(
-                                "Cannot serialize integer kind {:?}",
-                                int_kind
+                                "Cannot serialize integer kind {int_kind:?}"
                             ),
                             loc: get_loc(item),
                         })
@@ -286,7 +285,7 @@ impl<'a> CSerialize<'a> for Type {
                     FloatKind::Float => write!(writer, "float complex")?,
                     FloatKind::Double => write!(writer, "double complex")?,
                     FloatKind::LongDouble => {
-                        write!(writer, "long double complex")?
+                        write!(writer, "long double complex")?;
                     }
                     FloatKind::Float128 => write!(writer, "__complex128")?,
                 }
@@ -294,9 +293,9 @@ impl<'a> CSerialize<'a> for Type {
             TypeKind::Alias(type_id) => {
                 if let Some(name) = self.name() {
                     if self.is_const() {
-                        write!(writer, "const {}", name)?;
+                        write!(writer, "const {name}")?;
                     } else {
-                        write!(writer, "{}", name)?;
+                        write!(writer, "{name}")?;
                     }
                 } else {
                     type_id.serialize(ctx, (), stack, writer)?;
@@ -304,7 +303,7 @@ impl<'a> CSerialize<'a> for Type {
             }
             TypeKind::Array(type_id, length) => {
                 type_id.serialize(ctx, (), stack, writer)?;
-                write!(writer, " [{}]", length)?
+                write!(writer, " [{length}]")?;
             }
             TypeKind::Function(signature) => {
                 if self.is_const() {
@@ -320,7 +319,7 @@ impl<'a> CSerialize<'a> for Type {
 
                 write!(writer, " (")?;
                 while let Some(item) = stack.pop() {
-                    write!(writer, "{}", item)?;
+                    write!(writer, "{item}")?;
                 }
                 write!(writer, ")")?;
 
@@ -342,14 +341,14 @@ impl<'a> CSerialize<'a> for Type {
                             type_id.serialize(ctx, (), &mut stack, buf)
                         },
                     )?;
-                    write!(writer, ")")?
+                    write!(writer, ")")?;
                 }
             }
             TypeKind::ResolvedTypeRef(type_id) => {
                 if self.is_const() {
                     write!(writer, "const ")?;
                 }
-                type_id.serialize(ctx, (), stack, writer)?
+                type_id.serialize(ctx, (), stack, writer)?;
             }
             TypeKind::Pointer(type_id) => {
                 if self.is_const() {
@@ -357,7 +356,7 @@ impl<'a> CSerialize<'a> for Type {
                 } else {
                     stack.push("*".to_owned());
                 }
-                type_id.serialize(ctx, (), stack, writer)?
+                type_id.serialize(ctx, (), stack, writer)?;
             }
             TypeKind::Comp(comp_info) => {
                 if self.is_const() {
@@ -367,9 +366,9 @@ impl<'a> CSerialize<'a> for Type {
                 let name = item.canonical_name(ctx);
 
                 match comp_info.kind() {
-                    CompKind::Struct => write!(writer, "struct {}", name)?,
-                    CompKind::Union => write!(writer, "union {}", name)?,
-                };
+                    CompKind::Struct => write!(writer, "struct {name}")?,
+                    CompKind::Union => write!(writer, "union {name}")?,
+                }
             }
             TypeKind::Enum(_enum_ty) => {
                 if self.is_const() {
@@ -377,20 +376,20 @@ impl<'a> CSerialize<'a> for Type {
                 }
 
                 let name = item.canonical_name(ctx);
-                write!(writer, "enum {}", name)?;
+                write!(writer, "enum {name}")?;
             }
             ty => {
                 return Err(CodegenError::Serialize {
-                    msg: format!("Cannot serialize type kind {:?}", ty),
+                    msg: format!("Cannot serialize type kind {ty:?}"),
                     loc: get_loc(item),
                 })
             }
-        };
+        }
 
         if !stack.is_empty() {
             write!(writer, " ")?;
             while let Some(item) = stack.pop() {
-                write!(writer, "{}", item)?;
+                write!(writer, "{item}")?;
             }
         }
 

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

@@ -7,7 +7,7 @@ use crate::ir::context::BindgenContext;
 use crate::ir::layout::Layout;
 use crate::ir::ty::{Type, TypeKind};
 use crate::FieldVisibilityKind;
-use proc_macro2::{self, Ident, Span};
+use proc_macro2::{Ident, Span};
 use std::cmp;
 
 const MAX_GUARANTEED_ALIGN: usize = 8;
@@ -28,6 +28,7 @@ pub(crate) struct StructLayoutTracker<'a> {
     max_field_align: usize,
     last_field_was_bitfield: bool,
     visibility: FieldVisibilityKind,
+    last_field_was_flexible_array: bool,
 }
 
 /// Returns a size aligned to a given value.
@@ -110,6 +111,7 @@ impl<'a> StructLayoutTracker<'a> {
             latest_field_layout: None,
             max_field_align: 0,
             last_field_was_bitfield: false,
+            last_field_was_flexible_array: false,
         }
     }
 
@@ -121,6 +123,10 @@ impl<'a> StructLayoutTracker<'a> {
         self.is_rust_union
     }
 
+    pub(crate) fn saw_flexible_array(&mut self) {
+        self.last_field_was_flexible_array = true;
+    }
+
     pub(crate) fn saw_vtable(&mut self) {
         debug!("saw vtable for {}", self.name);
 
@@ -142,7 +148,7 @@ impl<'a> StructLayoutTracker<'a> {
     }
 
     pub(crate) fn saw_bitfield_unit(&mut self, layout: Layout) {
-        debug!("saw bitfield unit for {}: {:?}", self.name, layout);
+        debug!("saw bitfield unit for {}: {layout:?}", self.name);
 
         self.align_to_latest_field(layout);
 
@@ -242,12 +248,9 @@ impl<'a> StructLayoutTracker<'a> {
             );
 
             debug!(
-                "align field {} to {}/{} with {} padding bytes {:?}",
-                field_name,
+                "align field {field_name} to {}/{} with {padding_bytes} padding bytes {field_layout:?}",
                 self.latest_offset,
                 field_offset.unwrap_or(0) / 8,
-                padding_bytes,
-                field_layout
             );
 
             let padding_align = if force_padding {
@@ -263,15 +266,19 @@ impl<'a> StructLayoutTracker<'a> {
             }
         };
 
-        self.latest_offset += field_layout.size;
+        if is_union {
+            self.latest_offset =
+                cmp::max(self.latest_offset, field_layout.size);
+        } else {
+            self.latest_offset += field_layout.size;
+        }
         self.latest_field_layout = Some(field_layout);
         self.max_field_align =
             cmp::max(self.max_field_align, field_layout.align);
         self.last_field_was_bitfield = false;
 
         debug!(
-            "Offset: {}: {} -> {}",
-            field_name,
+            "Offset: {field_name}: {} -> {}",
             self.latest_offset - field_layout.size,
             self.latest_offset
         );
@@ -295,14 +302,18 @@ impl<'a> StructLayoutTracker<'a> {
             return None;
         }
 
+        // Also doesn't make sense for structs with flexible array members
+        if self.last_field_was_flexible_array {
+            return None;
+        }
+
         if self.latest_offset == comp_layout.size {
             // This struct does not contain tail padding.
             return None;
         }
 
         trace!(
-            "need a tail padding field for {}: offset {} -> size {}",
-            comp_name,
+            "need a tail padding field for {comp_name}: offset {} -> size {}",
             self.latest_offset,
             comp_layout.size
         );
@@ -314,10 +325,7 @@ impl<'a> StructLayoutTracker<'a> {
         &mut self,
         layout: Layout,
     ) -> Option<proc_macro2::TokenStream> {
-        debug!(
-            "pad_struct:\n\tself = {:#?}\n\tlayout = {:#?}",
-            self, layout
-        );
+        debug!("pad_struct:\n\tself = {self:#?}\n\tlayout = {layout:#?}");
 
         if layout.size < self.latest_offset {
             warn!(
@@ -333,7 +341,7 @@ impl<'a> StructLayoutTracker<'a> {
             return None;
         }
 
-        let repr_align = self.ctx.options().rust_features().repr_align;
+        let repr_align = true;
 
         // We always pad to get to the correct size if the struct is one of
         // those we can't align properly.
@@ -357,7 +365,7 @@ impl<'a> StructLayoutTracker<'a> {
                 Layout::new(padding_bytes, layout.align)
             };
 
-            debug!("pad bytes to struct {}, {:?}", self.name, layout);
+            debug!("pad bytes to struct {}, {layout:?}", self.name);
 
             Some(self.padding_field(layout))
         } else {
@@ -366,7 +374,7 @@ impl<'a> StructLayoutTracker<'a> {
     }
 
     pub(crate) fn requires_explicit_align(&self, layout: Layout) -> bool {
-        let repr_align = self.ctx.options().rust_features().repr_align;
+        let repr_align = true;
 
         // Always force explicit repr(align) for stuff more than 16-byte aligned
         // to work-around https://github.com/rust-lang/rust/issues/54341.
@@ -390,13 +398,13 @@ impl<'a> StructLayoutTracker<'a> {
     }
 
     fn padding_field(&mut self, layout: Layout) -> proc_macro2::TokenStream {
-        let ty = helpers::blob(self.ctx, layout);
+        let ty = helpers::blob(self.ctx, layout, false);
         let padding_count = self.padding_count;
 
         self.padding_count += 1;
 
         let padding_field_name = Ident::new(
-            &format!("__bindgen_padding_{}", padding_count),
+            &format!("__bindgen_padding_{padding_count}"),
             Span::call_site(),
         );
 
@@ -411,23 +419,22 @@ impl<'a> StructLayoutTracker<'a> {
 
     /// Returns whether the new field is known to merge with a bitfield.
     ///
-    /// This is just to avoid doing the same check also in pad_field.
+    /// This is just to avoid doing the same check also in `pad_field`.
     fn align_to_latest_field(&mut self, new_field_layout: Layout) -> bool {
         if self.is_packed {
             // Skip to align fields when packed.
             return false;
         }
 
-        let layout = match self.latest_field_layout {
-            Some(l) => l,
-            None => return false,
+        let Some(layout) = self.latest_field_layout else {
+            return false;
         };
 
         // If it was, we may or may not need to align, depending on what the
         // current field alignment and the bitfield size and alignment are.
         debug!(
-            "align_to_bitfield? {}: {:?} {:?}",
-            self.last_field_was_bitfield, layout, new_field_layout
+            "align_to_bitfield? {}: {layout:?} {new_field_layout:?}",
+            self.last_field_was_bitfield,
         );
 
         // Avoid divide-by-zero errors if align is 0.

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

@@ -18,7 +18,7 @@ impl DepfileSpec {
 
         let mut buf = format!("{}:", escape(&self.output_module));
         for file in deps {
-            buf = format!("{} {}", buf, escape(file));
+            buf = format!("{buf} {}", escape(file));
         }
         buf
     }

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

@@ -6,33 +6,9 @@ use std::fmt::Write;
 use std::io::{self, BufRead, BufReader};
 use std::{borrow::Cow, fs::File};
 
-use annotate_snippets::{
-    display_list::{DisplayList, FormatOptions},
-    snippet::{Annotation, Slice as ExtSlice, Snippet},
-};
-
-use annotate_snippets::snippet::AnnotationType;
-
-#[derive(Clone, Copy, Debug)]
-pub(crate) enum Level {
-    Error,
-    Warn,
-    Info,
-    Note,
-    Help,
-}
+use annotate_snippets::{Renderer, Snippet};
 
-impl From<Level> for AnnotationType {
-    fn from(level: Level) -> Self {
-        match level {
-            Level::Error => Self::Error,
-            Level::Warn => Self::Warning,
-            Level::Info => Self::Info,
-            Level::Note => Self::Note,
-            Level::Help => Self::Help,
-        }
-    }
-}
+pub(crate) use annotate_snippets::Level;
 
 /// A `bindgen` diagnostic.
 #[derive(Default)]
@@ -78,55 +54,37 @@ impl<'a> Diagnostic<'a> {
             static INVOKED_BY_BUILD_SCRIPT: bool =  std::env::var_os("CARGO_CFG_TARGET_ARCH").is_some();
         }
 
-        let mut title = None;
         let mut footer = vec![];
         let mut slices = vec![];
-        if let Some((msg, level)) = &self.title {
-            title = Some(Annotation {
-                id: Some("bindgen"),
-                label: Some(msg.as_ref()),
-                annotation_type: (*level).into(),
-            })
-        }
+        let snippet = if let Some((msg, level)) = &self.title {
+            (*level).title(msg)
+        } else {
+            return;
+        };
 
         for (msg, level) in &self.footer {
-            footer.push(Annotation {
-                id: None,
-                label: Some(msg.as_ref()),
-                annotation_type: (*level).into(),
-            });
+            footer.push((*level).title(msg));
         }
 
         // add additional info that this is generated by bindgen
         // so as to not confuse with rustc warnings
-        footer.push(Annotation {
-            id: None,
-            label: Some("This diagnostic was generated by bindgen."),
-            annotation_type: AnnotationType::Info,
-        });
+        footer.push(
+            Level::Info.title("This diagnostic was generated by bindgen."),
+        );
 
         for slice in &self.slices {
             if let Some(source) = &slice.source {
-                slices.push(ExtSlice {
-                    source: source.as_ref(),
-                    line_start: slice.line.unwrap_or_default(),
-                    origin: slice.filename.as_deref(),
-                    annotations: vec![],
-                    fold: false,
-                })
+                let mut snippet = Snippet::source(source)
+                    .line_start(slice.line.unwrap_or_default());
+                if let Some(origin) = &slice.filename {
+                    snippet = snippet.origin(origin);
+                }
+                slices.push(snippet);
             }
         }
 
-        let snippet = Snippet {
-            title,
-            footer,
-            slices,
-            opt: FormatOptions {
-                color: true,
-                ..Default::default()
-            },
-        };
-        let dl = DisplayList::from(snippet);
+        let renderer = Renderer::styled();
+        let dl = renderer.render(snippet.snippets(slices).footers(footer));
 
         if INVOKED_BY_BUILD_SCRIPT.with(Clone::clone) {
             // This is just a hack which hides the `warning:` added by cargo at the beginning of
@@ -135,10 +93,10 @@ impl<'a> Diagnostic<'a> {
             let hide_warning = "\r        \r";
             let string = dl.to_string();
             for line in string.lines() {
-                println!("cargo:warning={}{}", hide_warning, line);
+                println!("cargo:warning={hide_warning}{line}");
             }
         } else {
-            eprintln!("{}\n", dl);
+            eprintln!("{dl}\n");
         }
     }
 }
@@ -168,8 +126,7 @@ impl<'a> Slice<'a> {
         line: usize,
         col: usize,
     ) -> &mut Self {
-        write!(name, ":{}:{}", line, col)
-            .expect("Writing to a string cannot fail");
+        write!(name, ":{line}:{col}").expect("Writing to a string cannot fail");
         self.filename = Some(name);
         self.line = Some(line);
         self

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

@@ -2,7 +2,7 @@
 //! and/or CI when the `__testing_only_extra_assertions` feature is enabled.
 
 /// Simple macro that forwards to assert! when using
-/// __testing_only_extra_assertions.
+/// `__testing_only_extra_assertions`.
 macro_rules! extra_assert {
     ( $cond:expr ) => {
         if cfg!(feature = "__testing_only_extra_assertions") {