Auto merge of rust-lang#138630 - matthiaskrgr:rollup-kk1gogr, r=matthiaskrgr

Rollup of 7 pull requests

Successful merges:

 - rust-lang#138384 (Move `hir::Item::ident` into `hir::ItemKind`.)
 - rust-lang#138508 (Clarify "owned data" in E0515.md)
 - rust-lang#138531 (Store test diffs in job summaries and improve analysis formatting)
 - rust-lang#138533 (Only use `DIST_TRY_BUILD` for try jobs that were not selected explicitly)
 - rust-lang#138556 (Fix ICE: attempted to remap an already remapped filename)
 - rust-lang#138608 (rustc_target: Add target feature constraints for LoongArch)
 - rust-lang#138619 (Flatten `if`s in `rustc_codegen_ssa`)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

clippy_lints/src/arbitrary_source_item_ordering.rs

@@ -5,7 +5,7 @@ use clippy_config::types::{
 };
 use clippy_utils::diagnostics::span_lint_and_note;
 use rustc_hir::{
-    AssocItemKind, FieldDef, HirId, ImplItemRef, IsAuto, Item, ItemKind, Mod, QPath, TraitItemRef, TyKind, UseKind,
+    AssocItemKind, FieldDef, HirId, ImplItemRef, IsAuto, Item, ItemKind, Mod, QPath, TraitItemRef, TyKind,
     Variant, VariantData,
 };
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -178,8 +178,8 @@ impl ArbitrarySourceItemOrdering {
     /// Produces a linting warning for incorrectly ordered item members.
     fn lint_member_name<T: LintContext>(
         cx: &T,
-        ident: &rustc_span::symbol::Ident,
-        before_ident: &rustc_span::symbol::Ident,
+        ident: &rustc_span::Ident,
+        before_ident: &rustc_span::Ident,
     ) {
         span_lint_and_note(
             cx,
@@ -192,21 +192,21 @@ impl ArbitrarySourceItemOrdering {
     }
 
     fn lint_member_item<T: LintContext>(cx: &T, item: &Item<'_>, before_item: &Item<'_>) {
-        let span = if item.ident.as_str().is_empty() {
-            &item.span
+        let span = if let Some(ident) = item.kind.ident() {
+            ident.span
         } else {
-            &item.ident.span
+            item.span
         };
 
-        let (before_span, note) = if before_item.ident.as_str().is_empty() {
+        let (before_span, note) = if let Some(ident) = before_item.kind.ident() {
             (
-                &before_item.span,
-                "should be placed before the following item".to_owned(),
+                ident.span,
+                format!("should be placed before `{}`", ident.as_str(),),
             )
         } else {
             (
-                &before_item.ident.span,
-                format!("should be placed before `{}`", before_item.ident.as_str(),),
+                before_item.span,
+                "should be placed before the following item".to_owned(),
             )
         };
 
@@ -218,9 +218,9 @@ impl ArbitrarySourceItemOrdering {
         span_lint_and_note(
             cx,
             ARBITRARY_SOURCE_ITEM_ORDERING,
-            *span,
+            span,
             "incorrect ordering of items (must be alphabetically ordered)",
-            Some(*before_span),
+            Some(before_span),
             note,
         );
     }
@@ -244,7 +244,7 @@ impl ArbitrarySourceItemOrdering {
 impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         match &item.kind {
-            ItemKind::Enum(enum_def, _generics) if self.enable_ordering_for_enum => {
+            ItemKind::Enum(_, enum_def, _generics) if self.enable_ordering_for_enum => {
                 let mut cur_v: Option<&Variant<'_>> = None;
                 for variant in enum_def.variants {
                     if variant.span.in_external_macro(cx.sess().source_map()) {
@@ -259,7 +259,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                     cur_v = Some(variant);
                 }
             },
-            ItemKind::Struct(VariantData::Struct { fields, .. }, _generics) if self.enable_ordering_for_struct => {
+            ItemKind::Struct(_, VariantData::Struct { fields, .. }, _generics) if self.enable_ordering_for_struct => {
                 let mut cur_f: Option<&FieldDef<'_>> = None;
                 for field in *fields {
                     if field.span.in_external_macro(cx.sess().source_map()) {
@@ -274,7 +274,7 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                     cur_f = Some(field);
                 }
             },
-            ItemKind::Trait(is_auto, _safety, _generics, _generic_bounds, item_ref)
+            ItemKind::Trait(is_auto, _safety, _ident, _generics, _generic_bounds, item_ref)
                 if self.enable_ordering_for_trait && *is_auto == IsAuto::No =>
             {
                 let mut cur_t: Option<&TraitItemRef> = None;
@@ -351,50 +351,24 @@ impl<'tcx> LateLintPass<'tcx> for ArbitrarySourceItemOrdering {
                 continue;
             }
 
-            // The following exceptions (skipping with `continue;`) may not be
-            // complete, edge cases have not been explored further than what
-            // appears in the existing code base.
-            if item.ident.name == rustc_span::symbol::kw::Empty {
-                if let ItemKind::Impl(_) = item.kind {
-                    // Sorting trait impls for unnamed types makes no sense.
-                    if get_item_name(item).is_empty() {
-                        continue;
-                    }
-                } else if let ItemKind::ForeignMod { .. } = item.kind {
-                    continue;
-                } else if let ItemKind::GlobalAsm { .. } = item.kind {
-                    continue;
-                } else if let ItemKind::Use(path, use_kind) = item.kind {
-                    if path.segments.is_empty() {
-                        // Use statements that contain braces get caught here.
-                        // They will still be linted internally.
-                        continue;
-                    } else if path.segments.len() >= 2
-                        && (path.segments[0].ident.name == rustc_span::sym::std
-                            || path.segments[0].ident.name == rustc_span::sym::core)
-                        && path.segments[1].ident.name == rustc_span::sym::prelude
-                    {
-                        // Filters the autogenerated prelude use statement.
-                        // e.g. `use std::prelude::rustc_2021`
-                    } else if use_kind == UseKind::Glob {
-                        // Filters glob kinds of uses.
-                        // e.g. `use std::sync::*`
-                    } else {
-                        // This can be used for debugging.
-                        // println!("Unknown autogenerated use statement: {:?}", item);
-                    }
-                    continue;
-                }
-            }
+            let ident = if let Some(ident) = item.kind.ident() {
+                ident
+            } else if let ItemKind::Impl(_) = item.kind
+                && !get_item_name(item).is_empty()
+            {
+                rustc_span::Ident::empty() // FIXME: a bit strange, is there a better way to do it?
+            } else {
+                continue;
+            };
 
-            if item.ident.name.as_str().starts_with('_') {
+            if ident.name.as_str().starts_with('_') {
                 // Filters out unnamed macro-like impls for various derives,
                 // e.g. serde::Serialize or num_derive::FromPrimitive.
                 continue;
             }
 
-            if item.ident.name == rustc_span::sym::std && item.span.is_dummy() {
-                if let ItemKind::ExternCrate(None) = item.kind {
+            if ident.name == rustc_span::sym::std && item.span.is_dummy() {
+                if let ItemKind::ExternCrate(None, _) = item.kind {
                     // Filters the auto-included Rust standard library.
                     continue;
                 }
@@ -525,6 +499,8 @@ fn get_item_name(item: &Item<'_>) -> String {
                 String::new()
             }
         },
-        _ => item.ident.name.as_str().to_owned(),
+        // FIXME: `Ident::empty` for anonymous items is a bit strange, is there
+        // a better way to do it?
+        _ => item.kind.ident().unwrap_or(rustc_span::Ident::empty()).name.as_str().to_owned(),
     }
 }

clippy_lints/src/attrs/mod.rs

@@ -16,7 +16,7 @@ mod utils;
 use clippy_config::Conf;
 use clippy_utils::msrvs::{self, Msrv, MsrvStack};
 use rustc_ast::{self as ast, Attribute, MetaItemInner, MetaItemKind};
-use rustc_hir::{ImplItem, Item, TraitItem};
+use rustc_hir::{ImplItem, Item, ItemKind, TraitItem};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::sym;
@@ -466,8 +466,8 @@ impl Attributes {
 impl<'tcx> LateLintPass<'tcx> for Attributes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         let attrs = cx.tcx.hir_attrs(item.hir_id());
-        if is_relevant_item(cx, item) {
-            inline_always::check(cx, item.span, item.ident.name, attrs);
+        if let ItemKind::Fn { ident, .. } = item.kind && is_relevant_item(cx, item) {
+            inline_always::check(cx, item.span, ident.name, attrs);
         }
         repr_attributes::check(cx, item.span, attrs, self.msrv);
     }

clippy_lints/src/attrs/utils.rs

@@ -24,7 +24,7 @@ pub(super) fn is_relevant_item(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
     if let ItemKind::Fn { body: eid, .. } = item.kind {
         is_relevant_expr(cx, cx.tcx.typeck_body(eid), cx.tcx.hir_body(eid).value)
     } else {
-        true
+        false
     }
 }
 

clippy_lints/src/disallowed_types.rs

@@ -99,7 +99,7 @@ impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if let ItemKind::Use(path, UseKind::Single) = &item.kind {
+        if let ItemKind::Use(path, UseKind::Single(_)) = &item.kind {
             for res in &path.res {
                 self.check_res_emit(cx, res, item.span);
             }

clippy_lints/src/enum_clike.rs

@@ -38,7 +38,7 @@ impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
         if cx.tcx.data_layout.pointer_size.bits() != 64 {
             return;
         }
-        if let ItemKind::Enum(def, _) = &item.kind {
+        if let ItemKind::Enum(_, def, _) = &item.kind {
             for var in def.variants {
                 if let Some(anon_const) = &var.disr_expr {
                     let def_id = cx.tcx.hir_body_owner_def_id(anon_const.body);

clippy_lints/src/error_impl_error.rs

@@ -37,8 +37,8 @@ declare_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
 impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
         match item.kind {
-            ItemKind::TyAlias(..)
-                if item.ident.name == sym::Error
+            ItemKind::TyAlias(ident, ..)
+                if ident.name == sym::Error
                     && is_visible_outside_module(cx, item.owner_id.def_id)
                     && let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
                     && let Some(error_def_id) = cx.tcx.get_diagnostic_item(sym::Error)
@@ -47,7 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
                 span_lint(
                     cx,
                     ERROR_IMPL_ERROR,
-                    item.ident.span,
+                    ident.span,
                     "exported type alias named `Error` that implements `Error`",
                 );
             },

clippy_lints/src/escape.rs

@@ -91,7 +91,7 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal {
             }
 
             // find `self` ty for this trait if relevant
-            if let ItemKind::Trait(_, _, _, _, items) = item.kind {
+            if let ItemKind::Trait(_, _, _, _, _, items) = item.kind {
                 for trait_item in items {
                     if trait_item.id.owner_id.def_id == fn_def_id {
                         // be sure we have `self` parameter in this function

clippy_lints/src/excessive_bools.rs

@@ -122,7 +122,7 @@ fn check_fn_decl(cx: &LateContext<'_>, decl: &FnDecl<'_>, sp: Span, max: u64) {
 
 impl<'tcx> LateLintPass<'tcx> for ExcessiveBools {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
-        if let ItemKind::Struct(variant_data, _) = &item.kind
+        if let ItemKind::Struct(_, variant_data, _) = &item.kind
             && variant_data.fields().len() as u64 > self.max_struct_bools
             && has_n_bools(
                 variant_data.fields().iter().map(|field| field.ty),

clippy_lints/src/exhaustive_items.rs

@@ -76,7 +76,7 @@ impl LateLintPass<'_> for ExhaustiveItems {
                 "exported enums should not be exhaustive",
                 [].as_slice(),
             ),
-            ItemKind::Struct(v, ..) => (
+            ItemKind::Struct(_, v, ..) => (
                 EXHAUSTIVE_STRUCTS,
                 "exported structs should not be exhaustive",
                 v.fields(),

clippy_lints/src/functions/result.rs

@@ -103,7 +103,7 @@ fn check_result_large_err<'tcx>(cx: &LateContext<'tcx>, err_ty: Ty<'tcx>, hir_ty
             .did()
             .as_local()
         && let hir::Node::Item(item) = cx.tcx.hir_node_by_def_id(local_def_id)
-        && let hir::ItemKind::Enum(ref def, _) = item.kind
+        && let hir::ItemKind::Enum(_, ref def, _) = item.kind
     {
         let variants_size = AdtVariantInfo::new(cx, *adt, subst);
         if let Some((first_variant, variants)) = variants_size.split_first()