partial rustfmt

Author: dingxiangfei2009

bindgen/clang.rs

@@ -246,11 +246,10 @@ impl Cursor {
     pub(crate) fn is_toplevel(&self) -> bool {
         let mut semantic_parent = self.fallible_semantic_parent();
 
-        while semantic_parent.is_some() &&
-            (semantic_parent.unwrap().kind() == CXCursor_Namespace ||
-                semantic_parent.unwrap().kind() ==
-                    CXCursor_NamespaceAlias ||
-                semantic_parent.unwrap().kind() == CXCursor_NamespaceRef)
+        while semantic_parent.is_some()
+            && (semantic_parent.unwrap().kind() == CXCursor_Namespace
+                || semantic_parent.unwrap().kind() == CXCursor_NamespaceAlias
+                || semantic_parent.unwrap().kind() == CXCursor_NamespaceRef)
         {
             semantic_parent =
                 semantic_parent.unwrap().fallible_semantic_parent();
@@ -267,9 +266,9 @@ impl Cursor {
     pub(crate) fn is_template_like(&self) -> bool {
         matches!(
             self.kind(),
-            CXCursor_ClassTemplate |
-                CXCursor_ClassTemplatePartialSpecialization |
-                CXCursor_TypeAliasTemplateDecl
+            CXCursor_ClassTemplate
+                | CXCursor_ClassTemplatePartialSpecialization
+                | CXCursor_TypeAliasTemplateDecl
         )
     }
 
@@ -296,9 +295,9 @@ impl Cursor {
     /// Is the referent a fully specialized template specialization without any
     /// remaining free template arguments?
     pub(crate) fn is_fully_specialized_template(&self) -> bool {
-        self.is_template_specialization() &&
-            self.kind() != CXCursor_ClassTemplatePartialSpecialization &&
-            self.num_template_args().unwrap_or(0) > 0
+        self.is_template_specialization()
+            && self.kind() != CXCursor_ClassTemplatePartialSpecialization
+            && self.num_template_args().unwrap_or(0) > 0
     }
 
     /// Is the referent a template specialization that still has remaining free
@@ -324,9 +323,9 @@ impl Cursor {
     pub(crate) fn is_template_parameter(&self) -> bool {
         matches!(
             self.kind(),
-            CXCursor_TemplateTemplateParameter |
-                CXCursor_TemplateTypeParameter |
-                CXCursor_NonTypeTemplateParameter
+            CXCursor_TemplateTemplateParameter
+                | CXCursor_TemplateTypeParameter
+                | CXCursor_NonTypeTemplateParameter
         )
     }
 
@@ -664,9 +663,9 @@ impl Cursor {
         // inline function without a definition, and it's not a defaulted
         // function, we can reasonably safely conclude that it's a deleted
         // function.
-        self.is_inlined_function() &&
-            self.definition().is_none() &&
-            !self.is_defaulted_function()
+        self.is_inlined_function()
+            && self.definition().is_none()
+            && !self.is_defaulted_function()
     }
 
     /// Is the referent a bit field declaration?
@@ -788,11 +787,11 @@ impl Cursor {
                 let found_attr = &mut found_attrs[idx];
                 if !*found_attr {
                     // `attr.name` and` attr.token_kind` are checked against unexposed attributes only.
-                    if attr.kind == Some(kind) ||
-                        (kind == CXCursor_UnexposedAttr &&
-                            cur.tokens().iter().any(|t| {
-                                t.kind == attr.token_kind &&
-                                    t.spelling() == attr.name
+                    if attr.kind == Some(kind)
+                        || (kind == CXCursor_UnexposedAttr
+                            && cur.tokens().iter().any(|t| {
+                                t.kind == attr.token_kind
+                                    && t.spelling() == attr.name
                             }))
                     {
                         *found_attr = true;
@@ -1408,12 +1407,12 @@ impl Type {
     /// to.
     pub(crate) fn pointee_type(&self) -> Option<Type> {
         match self.kind() {
-            CXType_Pointer |
-            CXType_RValueReference |
-            CXType_LValueReference |
-            CXType_MemberPointer |
-            CXType_BlockPointer |
-            CXType_ObjCObjectPointer => {
+            CXType_Pointer
+            | CXType_RValueReference
+            | CXType_LValueReference
+            | CXType_MemberPointer
+            | CXType_BlockPointer
+            | CXType_ObjCObjectPointer => {
                 let ret = Type {
                     x: unsafe { clang_getPointeeType(self.x) },
                 };
@@ -1516,12 +1515,12 @@ impl Type {
         // Yep, the spelling of this containing type-parameter is extremely
         // nasty... But can happen in <type_traits>. Unfortunately I couldn't
         // reduce it enough :(
-        self.template_args().is_some_and(|args| args.len() > 0) &&
-            !matches!(
+        self.template_args().is_some_and(|args| args.len() > 0)
+            && !matches!(
                 self.declaration().kind(),
-                CXCursor_ClassTemplatePartialSpecialization |
-                    CXCursor_TypeAliasTemplateDecl |
-                    CXCursor_TemplateTemplateParameter
+                CXCursor_ClassTemplatePartialSpecialization
+                    | CXCursor_TypeAliasTemplateDecl
+                    | CXCursor_TemplateTemplateParameter
             )
     }
 
@@ -1546,9 +1545,9 @@ impl Type {
                 .is_match(spelling.as_ref())
         }
 
-        self.kind() == CXType_Unexposed &&
-            (hacky_parse_associated_type(self.spelling()) ||
-                hacky_parse_associated_type(
+        self.kind() == CXType_Unexposed
+            && (hacky_parse_associated_type(self.spelling())
+                || hacky_parse_associated_type(
                     self.canonical_type().spelling(),
                 ))
     }

bindgen/ir/context.rs

@@ -252,9 +252,9 @@ where
     T: Copy + Into<ItemId>,
 {
     fn can_derive_partialord(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_partialord &&
-            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
-                CanDerive::Yes
+        ctx.options().derive_partialord
+            && ctx.lookup_can_derive_partialeq_or_partialord(*self)
+                == CanDerive::Yes
     }
 }
 
@@ -263,9 +263,9 @@ where
     T: Copy + Into<ItemId>,
 {
     fn can_derive_partialeq(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_partialeq &&
-            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
-                CanDerive::Yes
+        ctx.options().derive_partialeq
+            && ctx.lookup_can_derive_partialeq_or_partialord(*self)
+                == CanDerive::Yes
     }
 }
 
@@ -274,10 +274,10 @@ where
     T: Copy + Into<ItemId>,
 {
     fn can_derive_eq(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_eq &&
-            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
-                CanDerive::Yes &&
-            !ctx.lookup_has_float(*self)
+        ctx.options().derive_eq
+            && ctx.lookup_can_derive_partialeq_or_partialord(*self)
+                == CanDerive::Yes
+            && !ctx.lookup_has_float(*self)
     }
 }
 
@@ -286,10 +286,10 @@ where
     T: Copy + Into<ItemId>,
 {
     fn can_derive_ord(&self, ctx: &BindgenContext) -> bool {
-        ctx.options().derive_ord &&
-            ctx.lookup_can_derive_partialeq_or_partialord(*self) ==
-                CanDerive::Yes &&
-            !ctx.lookup_has_float(*self)
+        ctx.options().derive_ord
+            && ctx.lookup_can_derive_partialeq_or_partialord(*self)
+                == CanDerive::Yes
+            && !ctx.lookup_has_float(*self)
     }
 }
 
@@ -353,7 +353,7 @@ pub(crate) struct BindgenContext {
     /// hard errors while parsing duplicated macros, as well to allow macro
     /// expression parsing.
     ///
-    /// This needs to be an `std::HashMap` because the `cexpr` API requires it.
+    /// This needs to be an `std::HashMap` because the [`cexpr`] API requires it.
     parsed_macros: StdHashMap<Vec<u8>, cexpr::expr::EvalResult>,
 
     /// A map with all include locations.
@@ -702,11 +702,11 @@ If you encounter an error missing from this list, please file an issue or a PR!"
     ) {
         debug!("BindgenContext::add_item({item:?}, declaration: {declaration:?}, loc: {location:?}");
         debug_assert!(
-            declaration.is_some() ||
-                !item.kind().is_type() ||
-                item.kind().expect_type().is_builtin_or_type_param() ||
-                item.kind().expect_type().is_opaque(self, &item) ||
-                item.kind().expect_type().is_unresolved_ref(),
+            declaration.is_some()
+                || !item.kind().is_type()
+                || item.kind().expect_type().is_builtin_or_type_param()
+                || item.kind().expect_type().is_opaque(self, &item)
+                || item.kind().expect_type().is_unresolved_ref(),
             "Adding a type without declaration?"
         );
 
@@ -1067,10 +1067,10 @@ If you encounter an error missing from this list, please file an issue or a PR!"
             };
 
             match *ty.kind() {
-                TypeKind::Comp(..) |
-                TypeKind::TemplateAlias(..) |
-                TypeKind::Enum(..) |
-                TypeKind::Alias(..) => {}
+                TypeKind::Comp(..)
+                | TypeKind::TemplateAlias(..)
+                | TypeKind::Enum(..)
+                | TypeKind::Alias(..) => {}
                 _ => continue,
             }
 
@@ -1665,9 +1665,9 @@ If you encounter an error missing from this list, please file an issue or a PR!"
 
         for child in children.iter().rev() {
             match child.kind() {
-                clang_sys::CXCursor_TypeRef |
-                clang_sys::CXCursor_TypedefDecl |
-                clang_sys::CXCursor_TypeAliasDecl => {
+                clang_sys::CXCursor_TypeRef
+                | clang_sys::CXCursor_TypedefDecl
+                | clang_sys::CXCursor_TypeAliasDecl => {
                     // The `with_id` ID will potentially end up unused if we give up
                     // on this type (for example, because it has const value
                     // template args), so if we pass `with_id` as the parent, it is
@@ -1691,8 +1691,8 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                         child,
                     )?;
 
-                    if num_expected_template_args == 0 ||
-                        child.has_at_least_num_children(
+                    if num_expected_template_args == 0
+                        || child.has_at_least_num_children(
                             num_expected_template_args,
                         )
                     {
@@ -1864,8 +1864,8 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                 //   * we have already parsed and resolved this type, and
                 //     there's nothing left to do.
                 if let Some(location) = location {
-                    if decl.cursor().is_template_like() &&
-                        *ty != decl.cursor().cur_type()
+                    if decl.cursor().is_template_like()
+                        && *ty != decl.cursor().cur_type()
                     {
                         // For specialized type aliases, there's no way to get the
                         // template parameters as of this writing (for a struct
@@ -1877,10 +1877,10 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                         // exposed.
                         //
                         // This is _tricky_, I know :(
-                        if decl.cursor().kind() ==
-                            CXCursor_TypeAliasTemplateDecl &&
-                            !location.contains_cursor(CXCursor_TypeRef) &&
-                            ty.canonical_type().is_valid_and_exposed()
+                        if decl.cursor().kind()
+                            == CXCursor_TypeAliasTemplateDecl
+                            && !location.contains_cursor(CXCursor_TypeRef)
+                            && ty.canonical_type().is_valid_and_exposed()
                         {
                             return None;
                         }
@@ -2129,6 +2129,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
     }
 
     /// Get the currently parsed macros.
+    /// This map only contains macros accepted by [`cexpr`]
     pub(crate) fn parsed_macros(
         &self,
     ) -> &StdHashMap<Vec<u8>, cexpr::expr::EvalResult> {
@@ -2376,9 +2377,9 @@ If you encounter an error missing from this list, please file an issue or a PR!"
     /// Is the given type a type from <stdint.h> that corresponds to a Rust primitive type?
     pub(crate) fn is_stdint_type(&self, name: &str) -> bool {
         match name {
-            "int8_t" | "uint8_t" | "int16_t" | "uint16_t" | "int32_t" |
-            "uint32_t" | "int64_t" | "uint64_t" | "uintptr_t" |
-            "intptr_t" | "ptrdiff_t" => true,
+            "int8_t" | "uint8_t" | "int16_t" | "uint16_t" | "int32_t"
+            | "uint32_t" | "int64_t" | "uint64_t" | "uintptr_t"
+            | "intptr_t" | "ptrdiff_t" => true,
             "size_t" | "ssize_t" => self.options.size_t_is_usize,
             _ => false,
         }
@@ -2406,11 +2407,11 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                 .filter(|&(_, item)| {
                     // If nothing is explicitly allowlisted, then everything is fair
                     // game.
-                    if self.options().allowlisted_types.is_empty() &&
-                        self.options().allowlisted_functions.is_empty() &&
-                        self.options().allowlisted_vars.is_empty() &&
-                        self.options().allowlisted_files.is_empty() &&
-                        self.options().allowlisted_items.is_empty()
+                    if self.options().allowlisted_types.is_empty()
+                        && self.options().allowlisted_functions.is_empty()
+                        && self.options().allowlisted_vars.is_empty()
+                        && self.options().allowlisted_files.is_empty()
+                        && self.options().allowlisted_items.is_empty()
                     {
                         return true;
                     }
@@ -2463,19 +2464,19 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                             // make the #[derive] analysis not be lame.
                             if !self.options().allowlist_recursively {
                                 match *ty.kind() {
-                                    TypeKind::Void |
-                                    TypeKind::NullPtr |
-                                    TypeKind::Int(..) |
-                                    TypeKind::Float(..) |
-                                    TypeKind::Complex(..) |
-                                    TypeKind::Array(..) |
-                                    TypeKind::Vector(..) |
-                                    TypeKind::Pointer(..) |
-                                    TypeKind::Reference(..) |
-                                    TypeKind::Function(..) |
-                                    TypeKind::ResolvedTypeRef(..) |
-                                    TypeKind::Opaque |
-                                    TypeKind::TypeParam => return true,
+                                    TypeKind::Void
+                                    | TypeKind::NullPtr
+                                    | TypeKind::Int(..)
+                                    | TypeKind::Float(..)
+                                    | TypeKind::Complex(..)
+                                    | TypeKind::Array(..)
+                                    | TypeKind::Vector(..)
+                                    | TypeKind::Pointer(..)
+                                    | TypeKind::Reference(..)
+                                    | TypeKind::Function(..)
+                                    | TypeKind::ResolvedTypeRef(..)
+                                    | TypeKind::Opaque
+                                    | TypeKind::TypeParam => return true,
                                     _ => {}
                                 }
                                 if self.is_stdint_type(&name) {
@@ -2793,9 +2794,9 @@ If you encounter an error missing from this list, please file an issue or a PR!"
     fn compute_cannot_derive_partialord_partialeq_or_eq(&mut self) {
         let _t = self.timer("compute_cannot_derive_partialord_partialeq_or_eq");
         assert!(self.cannot_derive_partialeq_or_partialord.is_none());
-        if self.options.derive_partialord ||
-            self.options.derive_partialeq ||
-            self.options.derive_eq
+        if self.options.derive_partialord
+            || self.options.derive_partialeq
+            || self.options.derive_eq
         {
             self.cannot_derive_partialeq_or_partialord =
                 Some(analyze::<CannotDerive>((
@@ -2842,8 +2843,8 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         // derive `Copy` or not.
         let id = id.into();
 
-        !self.lookup_has_type_param_in_array(id) &&
-            !self.cannot_derive_copy.as_ref().unwrap().contains(&id)
+        !self.lookup_has_type_param_in_array(id)
+            && !self.cannot_derive_copy.as_ref().unwrap().contains(&id)
     }
 
     /// Compute whether the type has type parameter in array.
@@ -3070,15 +3071,15 @@ impl TemplateParameters for PartialType {
         // Wouldn't it be nice if libclang would reliably give us this
         // information‽
         match self.decl().kind() {
-            clang_sys::CXCursor_ClassTemplate |
-            clang_sys::CXCursor_FunctionTemplate |
-            clang_sys::CXCursor_TypeAliasTemplateDecl => {
+            clang_sys::CXCursor_ClassTemplate
+            | clang_sys::CXCursor_FunctionTemplate
+            | clang_sys::CXCursor_TypeAliasTemplateDecl => {
                 let mut num_params = 0;
                 self.decl().visit(|c| {
                     match c.kind() {
-                        clang_sys::CXCursor_TemplateTypeParameter |
-                        clang_sys::CXCursor_TemplateTemplateParameter |
-                        clang_sys::CXCursor_NonTypeTemplateParameter => {
+                        clang_sys::CXCursor_TemplateTypeParameter
+                        | clang_sys::CXCursor_TemplateTemplateParameter
+                        | clang_sys::CXCursor_NonTypeTemplateParameter => {
                             num_params += 1;
                         }
                         _ => {}