Rollup merge of rust-lang#149790 - JonathanBrouwer:attr-path-perf, r=jdonszelmann

Remove `Span` from segments of `AttrPath`

r? jdonszelmann

Author: Kobzol

clippy_lints/src/attrs/allow_attributes.rs

@@ -4,18 +4,19 @@ use clippy_utils::is_from_proc_macro;
 use rustc_ast::{AttrStyle, Attribute};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, LintContext};
+use rustc_ast::attr::AttributeExt;
 
 // Separate each crate's features.
 pub fn check<'cx>(cx: &EarlyContext<'cx>, attr: &'cx Attribute) {
     if !attr.span.in_external_macro(cx.sess().source_map())
         && let AttrStyle::Outer = attr.style
-        && let Some(ident) = attr.ident()
+        && let Some(path_span) = attr.path_span()
         && !is_from_proc_macro(cx, attr)
     {
         #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
-        span_lint_and_then(cx, ALLOW_ATTRIBUTES, ident.span, "#[allow] attribute found", |diag| {
+        span_lint_and_then(cx, ALLOW_ATTRIBUTES, path_span, "#[allow] attribute found", |diag| {
             diag.span_suggestion(
-                ident.span,
+                path_span,
                 "replace it with",
                 "expect",
                 Applicability::MachineApplicable,

clippy_lints/src/attrs/mod.rs

@@ -574,16 +574,16 @@ impl EarlyLintPass for PostExpansionEarlyAttributes {
 
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         if let Some(items) = &attr.meta_item_list()
-            && let Some(ident) = attr.ident()
+            && let Some(name) = attr.name()
         {
-            if matches!(ident.name, sym::allow) && self.msrv.meets(msrvs::LINT_REASONS_STABILIZATION) {
+            if matches!(name, sym::allow) && self.msrv.meets(msrvs::LINT_REASONS_STABILIZATION) {
                 allow_attributes::check(cx, attr);
             }
-            if matches!(ident.name, sym::allow | sym::expect) && self.msrv.meets(msrvs::LINT_REASONS_STABILIZATION) {
-                allow_attributes_without_reason::check(cx, ident.name, items, attr);
+            if matches!(name, sym::allow | sym::expect) && self.msrv.meets(msrvs::LINT_REASONS_STABILIZATION) {
+                allow_attributes_without_reason::check(cx, name, items, attr);
             }
-            if is_lint_level(ident.name, attr.id) {
-                blanket_clippy_restriction_lints::check(cx, ident.name, items);
+            if is_lint_level(name, attr.id) {
+                blanket_clippy_restriction_lints::check(cx, name, items);
             }
             if items.is_empty() || !attr.has_name(sym::deprecated) {
                 return;

clippy_lints/src/attrs/useless_attribute.rs

@@ -15,7 +15,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, item: &Item, attrs: &[Attribute]) {
             return;
         }
         if let Some(lint_list) = &attr.meta_item_list()
-            && attr.ident().is_some_and(|ident| is_lint_level(ident.name, attr.id))
+            && attr.name().is_some_and(|name| is_lint_level(name, attr.id))
         {
             for lint in lint_list {
                 match item.kind {

clippy_lints/src/incompatible_msrv.rs

@@ -270,7 +270,7 @@ fn is_under_cfg_attribute(cx: &LateContext<'_>, hir_id: HirId) -> bool {
     cx.tcx.hir_parent_id_iter(hir_id).any(|id| {
         cx.tcx.hir_attrs(id).iter().any(|attr| {
             matches!(
-                attr.ident().map(|ident| ident.name),
+                attr.name(),
                 Some(sym::cfg_trace | sym::cfg_attr_trace)
             )
         })

clippy_lints/src/missing_doc.rs

@@ -287,8 +287,8 @@ fn is_doc_attr(attr: &Attribute) -> bool {
     match attr {
         Attribute::Parsed(AttributeKind::DocComment { .. }) => true,
         Attribute::Unparsed(attr)
-            if let [ident] = &*attr.path.segments
-                && ident.name == sym::doc =>
+            if let [name] = &*attr.path.segments
+                && *name == sym::doc =>
         {
             matches!(attr.args, AttrArgs::Eq { .. })
         },

clippy_utils/src/attrs.rs

@@ -20,10 +20,11 @@ pub fn get_builtin_attr<'a, A: AttributeExt + 'a>(
     name: Symbol,
 ) -> impl Iterator<Item = &'a A> {
     attrs.iter().filter(move |attr| {
-        if let Some([clippy, segment2]) = attr.ident_path().as_deref()
-            && clippy.name == sym::clippy
+        if let [clippy, segment2] = &*attr.path()
+            && *clippy == sym::clippy
         {
-            let new_name = match segment2.name {
+            let path_span = attr.path_span().expect("Clippy attributes are unparsed and have a span");
+            let new_name = match *segment2 {
                 sym::cyclomatic_complexity => Some("cognitive_complexity"),
                 sym::author
                 | sym::version
@@ -35,25 +36,25 @@ pub fn get_builtin_attr<'a, A: AttributeExt + 'a>(
                 | sym::has_significant_drop
                 | sym::format_args => None,
                 _ => {
-                    sess.dcx().span_err(segment2.span, "usage of unknown attribute");
+                    sess.dcx().span_err(path_span, "usage of unknown attribute");
                     return false;
                 },
             };
 
             match new_name {
                 Some(new_name) => {
                     sess.dcx()
-                        .struct_span_err(segment2.span, "usage of deprecated attribute")
+                        .struct_span_err(path_span, "usage of deprecated attribute")
                         .with_span_suggestion(
-                            segment2.span,
+                            path_span,
                             "consider using",
-                            new_name,
+                            format!("clippy::{}", new_name),
                             Applicability::MachineApplicable,
                         )
                         .emit();
                     false
                 },
-                None => segment2.name == name,
+                None => *segment2 == name,
             }
         } else {
             false

clippy_utils/src/check_proc_macro.rs

@@ -348,9 +348,9 @@ fn fn_kind_pat(tcx: TyCtxt<'_>, kind: &FnKind<'_>, body: &Body<'_>, hir_id: HirI
 fn attr_search_pat(attr: &Attribute) -> (Pat, Pat) {
     match attr.kind {
         AttrKind::Normal(..) => {
-            if let Some(ident) = attr.ident() {
+            if let Some(name) = attr.name() {
                 // NOTE: This will likely have false positives, like `allow = 1`
-                let ident_string = ident.to_string();
+                let ident_string = name.to_string();
                 if attr.style == AttrStyle::Outer {
                     (
                         Pat::OwnedMultiStr(vec!["#[".to_owned() + &ident_string, ident_string]),

tests/ui/renamed_builtin_attr.stderr

@@ -1,8 +1,8 @@
 error: usage of deprecated attribute
-  --> tests/ui/renamed_builtin_attr.rs:3:11
+  --> tests/ui/renamed_builtin_attr.rs:3:3
    |
 LL | #[clippy::cyclomatic_complexity = "1"]
-   |           ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `cognitive_complexity`
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `clippy::cognitive_complexity`
 
 error: aborting due to 1 previous error
 

tests/ui/unknown_attribute.stderr

@@ -1,8 +1,8 @@
 error: usage of unknown attribute
-  --> tests/ui/unknown_attribute.rs:3:11
+  --> tests/ui/unknown_attribute.rs:3:3
    |
 LL | #[clippy::unknown]
-   |           ^^^^^^^
+   |   ^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error