Move hir::Item::ident into hir::ItemKind.

`hir::Item` has an `ident` field.

- It's always non-empty for these item kinds: `ExternCrate`, `Static`,
  `Const`, `Fn`, `Macro`, `Mod`, `TyAlias`, `Enum`, `Struct`, `Union`,
  Trait`, TraitAalis`.

- It's always empty for these item kinds: `ForeignMod`, `GlobalAsm`,
  `Impl`.

- For `Use`, it is non-empty for `UseKind::Single` and empty for
  `UseKind::{Glob,ListStem}`.

All of this is quite non-obvious; the only documentation is a single
comment saying "The name might be a dummy name in case of anonymous
items". Some sites that handle items check for an empty ident, some
don't. This is a very C-like way of doing things, but this is Rust, we
have sum types, we can do this properly and never forget to check for
the exceptional case and never YOLO possibly empty identifiers (or
possibly dummy spans) around and hope that things will work out.

The commit is large but it's mostly obvious plumbing work. Some notable
things.

- A similar transformation makes sense for `ast::Item`, but this is
  already a big change. That can be done later.

- Lots of assertions are added to item lowering to ensure that
  identifiers are empty/non-empty as expected. These will be removable
  when `ast::Item` is done later.

- `ItemKind::Use` doesn't get an `Ident`, but `UseKind::Single` does.

- `lower_use_tree` is significantly simpler. No more confusing `&mut
  Ident` to deal with.

- `ItemKind::ident` is a new method, it returns an `Option<Ident>`. It's
  used with `unwrap` in a few places; sometimes it's hard to tell
  exactly which item kinds might occur. None of these unwraps fail on
  the test suite. It's conceivable that some might fail on alternative
  input. We can deal with those if/when they happen.

- In `trait_path` the `find_map`/`if let` is replaced with a loop, and
  things end up much clearer that way.

- `named_span` no longer checks for an empty name; instead the call site
  now checks for a missing identifier if necessary.

- `maybe_inline_local` doesn't need the `glob` argument, it can be
  computed in-function from the `renamed` argument.

- `arbitrary_source_item_ordering::check_mod` had a big `if` statement
  that was just getting the ident from the item kinds that had one. It
  could be mostly replaced by a single call to the new `ItemKind::ident`
  method.

- `ItemKind` grows from 56 to 64 bytes, but `Item` stays the same size,
  and that's what matters, because `ItemKind` only occurs within `Item`.

Author: nnethercote

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/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()

clippy_lints/src/item_name_repetitions.rs

@@ -8,7 +8,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::{EnumDef, FieldDef, Item, ItemKind, OwnerId, Variant, VariantData};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
-use rustc_span::Span;
+use rustc_span::{Ident, Span};
 use rustc_span::symbol::Symbol;
 
 declare_clippy_lint! {
@@ -196,16 +196,16 @@ fn have_no_extra_prefix(prefixes: &[&str]) -> bool {
     prefixes.iter().all(|p| p == &"" || p == &"_")
 }
 
-fn check_fields(cx: &LateContext<'_>, threshold: u64, item: &Item<'_>, fields: &[FieldDef<'_>]) {
+fn check_fields(cx: &LateContext<'_>, threshold: u64, ident: Ident, span: Span, fields: &[FieldDef<'_>]) {
     if (fields.len() as u64) < threshold {
         return;
     }
 
-    check_struct_name_repetition(cx, item, fields);
+    check_struct_name_repetition(cx, ident, fields);
 
     // if the SyntaxContext of the identifiers of the fields and struct differ dont lint them.
     // this prevents linting in macros in which the location of the field identifier names differ
-    if !fields.iter().all(|field| item.ident.span.eq_ctxt(field.ident.span)) {
+    if !fields.iter().all(|field| ident.span.eq_ctxt(field.ident.span)) {
         return;
     }
 
@@ -256,19 +256,19 @@ fn check_fields(cx: &LateContext<'_>, threshold: u64, item: &Item<'_>, fields: &
         span_lint_and_help(
             cx,
             STRUCT_FIELD_NAMES,
-            item.span,
+            span,
             format!("all fields have the same {what}fix: `{value}`"),
             None,
             format!("remove the {what}fixes"),
         );
     }
 }
 
-fn check_struct_name_repetition(cx: &LateContext<'_>, item: &Item<'_>, fields: &[FieldDef<'_>]) {
-    let snake_name = to_snake_case(item.ident.name.as_str());
+fn check_struct_name_repetition(cx: &LateContext<'_>, ident: Ident, fields: &[FieldDef<'_>]) {
+    let snake_name = to_snake_case(ident.name.as_str());
     let item_name_words: Vec<&str> = snake_name.split('_').collect();
     for field in fields {
-        if field.ident.span.eq_ctxt(item.ident.span) {
+        if field.ident.span.eq_ctxt(ident.span) {
             //consider linting only if the field identifier has the same SyntaxContext as the item(struct)
             let field_words: Vec<&str> = field.ident.name.as_str().split('_').collect();
             if field_words.len() >= item_name_words.len() {
@@ -397,19 +397,23 @@ fn check_variant(cx: &LateContext<'_>, threshold: u64, def: &EnumDef<'_>, item_n
 }
 
 impl LateLintPass<'_> for ItemNameRepetitions {
-    fn check_item_post(&mut self, _cx: &LateContext<'_>, _item: &Item<'_>) {
+    fn check_item_post(&mut self, _cx: &LateContext<'_>, item: &Item<'_>) {
+        let Some(_ident) = item.kind.ident() else { return };
+
         let last = self.modules.pop();
         assert!(last.is_some());
     }
 
     fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
-        let item_name = item.ident.name.as_str();
+        let Some(ident) = item.kind.ident() else { return };
+
+        let item_name = ident.name.as_str();
         let item_camel = to_camel_case(item_name);
         if !item.span.from_expansion() && is_present_in_source(cx, item.span) {
             if let [.., (mod_name, mod_camel, mod_owner_id)] = &*self.modules {
                 // constants don't have surrounding modules
                 if !mod_camel.is_empty() {
-                    if mod_name == &item.ident.name
+                    if mod_name == &ident.name
                         && let ItemKind::Mod(..) = item.kind
                         && (!self.allow_private_module_inception || cx.tcx.visibility(mod_owner_id.def_id).is_public())
                     {
@@ -438,7 +442,7 @@ impl LateLintPass<'_> for ItemNameRepetitions {
                                 Some(c) if is_word_beginning(c) => span_lint(
                                     cx,
                                     MODULE_NAME_REPETITIONS,
-                                    item.ident.span,
+                                    ident.span,
                                     "item name starts with its containing module's name",
                                 ),
                                 _ => (),
@@ -450,7 +454,7 @@ impl LateLintPass<'_> for ItemNameRepetitions {
                             span_lint(
                                 cx,
                                 MODULE_NAME_REPETITIONS,
-                                item.ident.span,
+                                ident.span,
                                 "item name ends with its containing module's name",
                             );
                         }
@@ -462,13 +466,13 @@ impl LateLintPass<'_> for ItemNameRepetitions {
             && span_is_local(item.span)
         {
             match item.kind {
-                ItemKind::Enum(def, _) => check_variant(cx, self.enum_threshold, &def, item_name, item.span),
-                ItemKind::Struct(VariantData::Struct { fields, .. }, _) => {
-                    check_fields(cx, self.struct_threshold, item, fields);
+                ItemKind::Enum(_, def, _) => check_variant(cx, self.enum_threshold, &def, item_name, item.span),
+                ItemKind::Struct(_, VariantData::Struct { fields, .. }, _) => {
+                    check_fields(cx, self.struct_threshold, ident, item.span, fields);
                 },
                 _ => (),
             }
         }
-        self.modules.push((item.ident.name, item_camel, item.owner_id));
+        self.modules.push((ident.name, item_camel, item.owner_id));
     }
 }