Wip

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/cfg_trace.rs

@@ -1,6 +1,6 @@
 use rustc_feature::AttributeTemplate;
 use rustc_hir::attrs::{AttributeKind, CfgEntry};
-use rustc_span::{Symbol, sym};
+use rustc_span::{Symbol, sym, Span};
 
 use crate::attributes::{CombineAttributeParser, ConvertFn};
 use crate::context::{AcceptContext, Stage};
@@ -12,8 +12,8 @@ pub(crate) struct CfgTraceParser;
 
 impl<S: Stage> CombineAttributeParser<S> for CfgTraceParser {
     const PATH: &[Symbol] = &[sym::cfg_trace];
-    type Item = CfgEntry;
-    const CONVERT: ConvertFn<Self::Item> = AttributeKind::CfgTrace;
+    type Item = (CfgEntry, Span);
+    const CONVERT: ConvertFn<Self::Item> = |c, _| AttributeKind::CfgTrace(c);
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
     const TEMPLATE: AttributeTemplate = CFG_TEMPLATE;
 
@@ -28,7 +28,7 @@ impl<S: Stage> CombineAttributeParser<S> for CfgTraceParser {
             return None;
         };
 
-        parse_cfg_entry(cx, entry).ok()
+        Some((parse_cfg_entry(cx, entry).ok()?, cx.attr_span))
     }
 }
 

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -653,7 +653,7 @@ pub enum AttributeKind {
 
     /// Represents `#[cfg]` trace attributes
     /// These are attributes left behind in the HIR after `#[cfg]` attributes are processed
-    CfgTrace(ThinVec<CfgEntry>, Span),
+    CfgTrace(ThinVec<(CfgEntry, Span)>),
 
     /// Represents `#[rustc_coinductive]`.
     Coinductive(Span),

src/librustdoc/clean/cfg.rs

@@ -739,9 +739,9 @@ pub(crate) fn extract_cfg_from_attrs<'a, I: Iterator<Item = &'a hir::Attribute>
             }
             continue;
         } else if !cfg_info.parent_is_doc_cfg
-            && let hir::Attribute::Parsed(AttributeKind::CfgTrace(cfgs, _)) = attr
+            && let hir::Attribute::Parsed(AttributeKind::CfgTrace(cfgs)) = attr
         {
-            for new_cfg in cfgs {
+            for (new_cfg, _) in cfgs {
                 cfg_info.current_cfg &= Cfg(new_cfg.clone());
             }
         }

src/tools/clippy/clippy_lints/src/incompatible_msrv.rs

@@ -9,6 +9,8 @@ use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::{CrateNum, DefId};
 use rustc_span::{ExpnKind, Span};
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::find_attr;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -268,11 +270,6 @@ impl<'tcx> LateLintPass<'tcx> for IncompatibleMsrv {
 /// attribute.
 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),
-                Some(sym::cfg_trace | sym::cfg_attr_trace)
-            )
-        })
+        find_attr!(cx.tcx.hir_attrs(id), AttributeKind::CfgTrace(..) | AttributeKind::CfgAttrTrace(..))
     })
 }

src/tools/clippy/clippy_lints/src/methods/is_empty.rs

@@ -5,7 +5,8 @@ use clippy_utils::res::MaybeResPath;
 use clippy_utils::{find_binding_init, get_parent_expr, is_inside_always_const_context};
 use rustc_hir::{Expr, HirId};
 use rustc_lint::{LateContext, LintContext};
-use rustc_span::sym;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::find_attr;
 
 use super::CONST_IS_EMPTY;
 
@@ -40,7 +41,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, receiver: &Expr<'_
 fn is_under_cfg(cx: &LateContext<'_>, id: HirId) -> bool {
     cx.tcx
         .hir_parent_id_iter(id)
-        .any(|id| cx.tcx.hir_attrs(id).iter().any(|attr| attr.has_name(sym::cfg_trace)))
+        .any(|id| find_attr!(cx.tcx.hir_attrs(id), AttributeKind::CfgTrace(..)))
 }
 
 /// Similar to [`clippy_utils::expr_or_init`], but does not go up the chain if the initialization

src/tools/clippy/clippy_lints/src/new_without_default.rs

@@ -9,6 +9,8 @@ use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::AssocKind;
 use rustc_session::impl_lint_pass;
 use rustc_span::sym;
+use rustc_hir::Attribute;
+use rustc_hir::attrs::AttributeKind;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -121,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                 let attrs_sugg = {
                     let mut sugg = String::new();
                     for attr in cx.tcx.hir_attrs(assoc_item_hir_id) {
-                        if !attr.has_name(sym::cfg_trace) {
+                        let Attribute::Parsed(AttributeKind::CfgTrace(attrs)) = attr else {
                             // This might be some other attribute that the `impl Default` ought to inherit.
                             // But it could also be one of the many attributes that:
                             // - can't be put on an impl block -- like `#[inline]`
@@ -131,10 +133,13 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                             // reduce the applicability
                             app = Applicability::MaybeIncorrect;
                             continue;
+                        };
+
+                        for (_, attr_span) in attrs {
+                            sugg.push_str(&snippet_with_applicability(cx.sess(), *attr_span, "_", &mut app));
+                            sugg.push('\n');
                         }
 
-                        sugg.push_str(&snippet_with_applicability(cx.sess(), attr.span(), "_", &mut app));
-                        sugg.push('\n');
                     }
                     sugg
                 };

src/tools/clippy/clippy_utils/src/lib.rs

@@ -121,6 +121,7 @@ use rustc_middle::ty::{
     self as rustc_ty, Binder, BorrowKind, ClosureKind, EarlyBinder, GenericArgKind, GenericArgsRef, IntTy, Ty, TyCtxt,
     TypeFlags, TypeVisitableExt, UintTy, UpvarCapture,
 };
+use rustc_hir::attrs::CfgEntry;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{Ident, Symbol, kw};
@@ -2401,17 +2402,12 @@ pub fn is_test_function(tcx: TyCtxt<'_>, fn_def_id: LocalDefId) -> bool {
 /// This only checks directly applied attributes, to see if a node is inside a `#[cfg(test)]` parent
 /// use [`is_in_cfg_test`]
 pub fn is_cfg_test(tcx: TyCtxt<'_>, id: HirId) -> bool {
-    tcx.hir_attrs(id).iter().any(|attr| {
-        if attr.has_name(sym::cfg_trace)
-            && let Some(items) = attr.meta_item_list()
-            && let [item] = &*items
-            && item.has_name(sym::test)
-        {
-            true
-        } else {
-            false
-        }
-    })
+    if let Some(cfgs) = find_attr!(tcx.hir_attrs(id), AttributeKind::CfgTrace(cfgs) => cfgs)
+        && cfgs.iter().any(|(cfg, _)| { matches!(cfg, CfgEntry::NameValue { name: sym::test, ..})}) {
+        true
+    } else {
+        false
+    }
 }
 
 /// Checks if any parent node of `HirId` has `#[cfg(test)]` attribute applied
@@ -2426,11 +2422,10 @@ pub fn is_in_test(tcx: TyCtxt<'_>, hir_id: HirId) -> bool {
 
 /// Checks if the item of any of its parents has `#[cfg(...)]` attribute applied.
 pub fn inherits_cfg(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
-    tcx.has_attr(def_id, sym::cfg_trace)
-        || tcx
+    find_attr!(tcx.get_all_attrs(def_id), AttributeKind::CfgTrace(..))
+        || find_attr!(tcx
             .hir_parent_iter(tcx.local_def_id_to_hir_id(def_id))
-            .flat_map(|(parent_id, _)| tcx.hir_attrs(parent_id))
-            .any(|attr| attr.has_name(sym::cfg_trace))
+            .flat_map(|(parent_id, _)| tcx.hir_attrs(parent_id)), AttributeKind::CfgTrace(..))
 }
 
 /// Walks up the HIR tree from the given expression in an attempt to find where the value is