Improving is_from_proc_macro

Finally, after a few months I finally release this 0.9.9 version of the final 'is_from_proc_macro'.
The main changes happen on:
  - Moving 'check_from_proc_macro.rs' from Clippy to rustc_lint
  - Applying a Jarcho's (yet to be merged) fix to that file (See rust-lang/rust-clippy#11538)
  - Change every occurence of 'is_from_proc_macro' to 'cx.in_proc_macro'
  - Added a new macro to 'rustc_lint/late.rs', now it checks if we're in Clippy, if we are indeed in Clippy, check if we're in a proc macro.
  - Apply some parallization to the checking with already provided functions (nothing too fancy, just using a parallization function)
  - Fix a bug on 'min_ident_chars.rs'
  - A few more things I don't remember...

You can test this commit with 'RUST_BACKTRACE=full x test src/tools/clippy --keep-stage=2'

Author: blyxyas

src/tools/clippy/clippy_utils/src/check_proc_macro.rs renamed to compiler/rustc_lint/src/check_proc_macro.rs

@@ -12,16 +12,16 @@
 //! code was written, and check if the span contains that text. Note this will only work correctly
 //! if the span is not from a `macro_rules` based macro.
 
-use rustc_ast::ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, UintTy};
+use rustc_ast::ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, TraitObjectSyntax, UintTy};
 use rustc_ast::token::CommentKind;
 use rustc_ast::AttrStyle;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
-    Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, HirId, Impl, ImplItem,
-    ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, MutTy, Node, QPath, TraitItem, TraitItemKind, Ty,
-    TyKind, UnOp, UnsafeSource, Unsafety, Variant, VariantData, YieldSource,
+    Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, FnRetTy, HirId, Impl,
+    ImplItem, ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, MutTy, Node, QPath, TraitItem,
+    TraitItemKind, Ty, TyKind, UnOp, UnsafeSource, Unsafety, Variant, VariantData, YieldSource,
 };
-use rustc_lint::{LateContext, LintContext};
+use crate::{LateContext, LintContext};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_span::symbol::Ident;
@@ -33,8 +33,6 @@ use rustc_target::spec::abi::Abi;
 pub enum Pat {
     /// A single string.
     Str(&'static str),
-    /// A single string.
-    OwnedStr(String),
     /// Any of the given strings.
     MultiStr(&'static [&'static str]),
     /// Any of the given strings.
@@ -47,7 +45,7 @@ pub enum Pat {
 
 /// Checks if the start and the end of the span's text matches the patterns. This will return false
 /// if the span crosses multiple files or if source is not available.
-fn span_matches_pat(sess: &Session, span: Span, start_pat: Pat, end_pat: Pat) -> bool {
+pub fn span_matches_pat(sess: &Session, span: Span, start_pat: Pat, end_pat: Pat) -> bool {
     let pos = sess.source_map().lookup_byte_offset(span.lo());
     let Some(ref src) = pos.sf.src else {
         return false;
@@ -59,14 +57,12 @@ fn span_matches_pat(sess: &Session, span: Span, start_pat: Pat, end_pat: Pat) ->
         let end_str = s.trim_end_matches(|c: char| c.is_whitespace() || c == ')' || c == ',');
         (match start_pat {
             Pat::Str(text) => start_str.starts_with(text),
-            Pat::OwnedStr(text) => start_str.starts_with(&text),
             Pat::MultiStr(texts) => texts.iter().any(|s| start_str.starts_with(s)),
             Pat::OwnedMultiStr(texts) => texts.iter().any(|s| start_str.starts_with(s)),
             Pat::Sym(sym) => start_str.starts_with(sym.as_str()),
             Pat::Num => start_str.as_bytes().first().map_or(false, u8::is_ascii_digit),
         } && match end_pat {
             Pat::Str(text) => end_str.ends_with(text),
-            Pat::OwnedStr(text) => end_str.starts_with(&text),
             Pat::MultiStr(texts) => texts.iter().any(|s| start_str.ends_with(s)),
             Pat::OwnedMultiStr(texts) => texts.iter().any(|s| start_str.starts_with(s)),
             Pat::Sym(sym) => end_str.ends_with(sym.as_str()),
@@ -125,6 +121,7 @@ fn qpath_search_pat(path: &QPath<'_>) -> (Pat, Pat) {
 fn expr_search_pat(tcx: TyCtxt<'_>, e: &Expr<'_>) -> (Pat, Pat) {
     match e.kind {
         ExprKind::ConstBlock(_) => (Pat::Str("const"), Pat::Str("}")),
+        // Parenthesis are skipped before the patterns are matched.
         ExprKind::Tup([]) => (Pat::Str(")"), Pat::Str("(")),
         ExprKind::Unary(UnOp::Deref, e) => (Pat::Str("*"), expr_search_pat(tcx, e).1),
         ExprKind::Unary(UnOp::Not, e) => (Pat::Str("!"), expr_search_pat(tcx, e).1),
@@ -286,21 +283,17 @@ 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(..) => {
-            let mut pat = if matches!(attr.style, AttrStyle::Outer) {
-                (Pat::Str("#["), Pat::Str("]"))
-            } else {
-                (Pat::Str("#!["), Pat::Str("]"))
-            };
-
-            if let Some(ident) = attr.ident() && let Pat::Str(old_pat) = pat.0 {
+            if let Some(ident) = attr.ident() {
                 // TODO: I feel like it's likely we can use `Cow` instead but this will require quite a bit of
                 // refactoring
                 // NOTE: This will likely have false positives, like `allow = 1`
-                pat.0 = Pat::OwnedMultiStr(vec![ident.to_string(), old_pat.to_owned()]);
-                pat.1 = Pat::Str("");
+                (
+                    Pat::OwnedMultiStr(vec![ident.to_string(), "#".to_owned()]),
+                    Pat::Str(""),
+                )
+            } else {
+                (Pat::Str("#"), Pat::Str("]"))
             }
-
-            pat
         },
         AttrKind::DocComment(_kind @ CommentKind::Line, ..) => {
             if matches!(attr.style, AttrStyle::Outer) {
@@ -322,32 +315,41 @@ fn attr_search_pat(attr: &Attribute) -> (Pat, Pat) {
 fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
     match ty.kind {
         TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
-        TyKind::Ptr(MutTy { mutbl, ty }) => (
-            if mutbl.is_mut() {
-                Pat::Str("*const")
-            } else {
-                Pat::Str("*mut")
-            },
-            ty_search_pat(ty).1,
-        ),
+        TyKind::Ptr(MutTy { ty, .. }) => (Pat::Str("*"), ty_search_pat(ty).1),
         TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ty_search_pat(ty).1),
         TyKind::BareFn(bare_fn) => (
-            Pat::OwnedStr(format!("{}{} fn", bare_fn.unsafety.prefix_str(), bare_fn.abi.name())),
-            ty_search_pat(ty).1,
+            if bare_fn.unsafety == Unsafety::Unsafe {
+                Pat::Str("unsafe")
+            } else if bare_fn.abi != Abi::Rust {
+                Pat::Str("extern")
+            } else {
+                Pat::MultiStr(&["fn", "extern"])
+            },
+            match bare_fn.decl.output {
+                FnRetTy::DefaultReturn(_) => {
+                    if let [.., ty] = bare_fn.decl.inputs {
+                        ty_search_pat(ty).1
+                    } else {
+                        Pat::Str("(")
+                    }
+                },
+                FnRetTy::Return(ty) => ty_search_pat(ty).1,
+            },
         ),
-        TyKind::Never => (Pat::Str("!"), Pat::Str("")),
-        TyKind::Tup(..) => (Pat::Str("("), Pat::Str(")")),
+        TyKind::Never => (Pat::Str("!"), Pat::Str("!")),
+        // Parenthesis are skipped before the patterns are matched.
+        TyKind::Tup([]) => (Pat::Str(")"), Pat::Str("(")),
+        TyKind::Tup([ty]) => ty_search_pat(ty),
+        TyKind::Tup([head, .., tail]) => (ty_search_pat(head).0, ty_search_pat(tail).1),
         TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
         TyKind::Path(qpath) => qpath_search_pat(&qpath),
-        // NOTE: This is missing `TraitObject`. It will always return true then.
+        TyKind::Infer => (Pat::Str("_"), Pat::Str("_")),
+        TyKind::TraitObject(_, _, TraitObjectSyntax::Dyn) => (Pat::Str("dyn"), Pat::Str("")),
+        // NOTE: `TraitObject` is incomplete. It will always return true then.
         _ => (Pat::Str(""), Pat::Str("")),
     }
 }
 
-fn ident_search_pat(ident: Ident) -> (Pat, Pat) {
-    (Pat::OwnedStr(ident.name.as_str().to_owned()), Pat::Str(""))
-}
-
 pub trait WithSearchPat<'cx> {
     type Context: LintContext;
     fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat);
@@ -406,7 +408,7 @@ impl<'cx> WithSearchPat<'cx> for Ident {
     type Context = LateContext<'cx>;
 
     fn search_pat(&self, _cx: &Self::Context) -> (Pat, Pat) {
-        ident_search_pat(*self)
+        (Pat::Sym(self.name), Pat::Sym(self.name))
     }
 
     fn span(&self) -> Span {
@@ -431,4 +433,4 @@ pub fn is_span_match(cx: &impl LintContext, span: Span) -> bool {
 /// Checks if the span actually refers to an if expression
 pub fn is_span_if(cx: &impl LintContext, span: Span) -> bool {
     span_matches_pat(cx.sess(), span, Pat::Str("if"), Pat::Str("}"))
-}
+}

compiler/rustc_lint/src/context.rs

@@ -509,6 +509,12 @@ pub struct LateContext<'tcx> {
 
     /// We are only looking at one module
     pub only_module: bool,
+
+    /// If we're in a procedural macro expansion
+    pub in_proc_macro: bool,
+
+    /// If the user executed `cargo clippy` (env. var. `CLIPPY_ARGS` is always defined)
+    pub(super) in_clippy: bool
 }
 
 /// Context for lint checking of the AST, after expansion, before lowering to HIR.

compiler/rustc_lint/src/late.rs

@@ -14,7 +14,8 @@
 //! upon. As the ast is traversed, this keeps track of the current lint level
 //! for all lint attributes.
 
-use crate::{passes::LateLintPassObject, LateContext, LateLintPass, LintStore};
+use crate::{passes::LateLintPassObject, LateContext, LateLintPass, LintStore, is_from_proc_macro};
+use hir::HirId;
 use rustc_ast as ast;
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::sync::join;
@@ -28,6 +29,11 @@ use rustc_span::Span;
 
 use std::any::Any;
 use std::cell::Cell;
+use std::env;
+
+thread_local! {
+    static MEOW: Cell<[HirId; 8]> = Cell::new([HirId::INVALID; 8]);
+}
 
 /// Extract the `LintStore` from the query context.
 /// This function exists because we've erased `LintStore` as `dyn Any` in the context.
@@ -36,6 +42,53 @@ pub fn unerased_lint_store(tcx: TyCtxt<'_>) -> &LintStore {
     store.downcast_ref().unwrap()
 }
 
+/// This macro checks if we're in Clippy, if that's the case,
+/// we'll check if the current token to be visited is in a proc macro.
+/// 
+/// This is useful for Clippy, so several lints that share the same token, can
+/// also share the `is_from_proc_macro` evaluation. We only evaluate if the two
+/// HirIds share parent and we're in a Clippy execution.
+/// 
+/// Each token is assigned a number, this number will be the index in the MEOW static
+/// `Cell`, so each token can evaluated separately (but still efficiently).
+/// 
+/// Indexes:
+/// 
+/// - Item: 0
+/// - Expr: 1
+/// - FieldDef: 2
+/// - Variant: 3
+/// - Type: 4
+/// - TraitItem: 5
+/// - ImplItem: 6
+/// - Attribute: 7
+/// 
+/// These indexes aren't in any particular order, they're
+/// better treated as separate variables packed in an array for
+/// the sake of optimization.
+macro_rules! clippy_in_proc_macro {
+    ($cx:expr, $it:expr, $id:expr, $meow:expr) => {
+        if $cx.context.in_clippy {
+            let parent_id = $cx.context.tcx.hir().parent_id($id);
+            let meow = MEOW.get();
+            if meow[$meow] != parent_id {
+                $cx.context.in_proc_macro = is_from_proc_macro(&$cx.context, $it);
+                let mut new_meow = meow;
+                new_meow[$meow] = parent_id;
+                MEOW.set(new_meow);
+            } else if rustc_index::Idx::index(parent_id.owner) == 0 {
+                $cx.context.in_proc_macro = is_from_proc_macro(&$cx.context, $it);
+            };
+        }
+    };
+
+    ($cx:expr, $it:expr, NO ID, $meow:expr) => {
+        if $cx.context.in_clippy {
+            $cx.context.in_proc_macro = is_from_proc_macro(&$cx.context, $it);
+        }
+    }
+}
+
 macro_rules! lint_callback { ($cx:expr, $f:ident, $($args:expr),*) => ({
     $cx.pass.$f(&$cx.context, $($args),*);
 }) }
@@ -133,6 +186,9 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
         self.context.generics = it.kind.generics();
         let old_cached_typeck_results = self.context.cached_typeck_results.take();
         let old_enclosing_body = self.context.enclosing_body.take();
+
+        clippy_in_proc_macro!(self, it, it.hir_id(), 0);
+
         self.with_lint_attrs(it.hir_id(), |cx| {
             cx.with_param_env(it.owner_id, |cx| {
                 lint_callback!(cx, check_item, it);
@@ -164,6 +220,7 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
     }
 
     fn visit_expr(&mut self, e: &'tcx hir::Expr<'tcx>) {
+        clippy_in_proc_macro!(self, e, e.hir_id, 1);
         ensure_sufficient_stack(|| {
             self.with_lint_attrs(e.hir_id, |cx| {
                 lint_callback!(cx, check_expr, e);
@@ -207,20 +264,23 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
     }
 
     fn visit_field_def(&mut self, s: &'tcx hir::FieldDef<'tcx>) {
+        clippy_in_proc_macro!(self, s, s.hir_id, 2);
         self.with_lint_attrs(s.hir_id, |cx| {
             lint_callback!(cx, check_field_def, s);
             hir_visit::walk_field_def(cx, s);
         })
     }
 
     fn visit_variant(&mut self, v: &'tcx hir::Variant<'tcx>) {
+        clippy_in_proc_macro!(self, v, v.hir_id, 3);
         self.with_lint_attrs(v.hir_id, |cx| {
             lint_callback!(cx, check_variant, v);
             hir_visit::walk_variant(cx, v);
         })
     }
 
     fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx>) {
+        clippy_in_proc_macro!(self, t, t.hir_id, 4);
         lint_callback!(self, check_ty, t);
         hir_visit::walk_ty(self, t);
     }
@@ -277,6 +337,7 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
     fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) {
         let generics = self.context.generics.take();
         self.context.generics = Some(&trait_item.generics);
+        clippy_in_proc_macro!(self, trait_item, trait_item.hir_id(), 5);
         self.with_lint_attrs(trait_item.hir_id(), |cx| {
             cx.with_param_env(trait_item.owner_id, |cx| {
                 lint_callback!(cx, check_trait_item, trait_item);
@@ -289,6 +350,7 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
     fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) {
         let generics = self.context.generics.take();
         self.context.generics = Some(&impl_item.generics);
+        clippy_in_proc_macro!(self, impl_item, impl_item.hir_id(), 6);
         self.with_lint_attrs(impl_item.hir_id(), |cx| {
             cx.with_param_env(impl_item.owner_id, |cx| {
                 lint_callback!(cx, check_impl_item, impl_item);
@@ -309,6 +371,12 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
     }
 
     fn visit_attribute(&mut self, attr: &'tcx ast::Attribute) {
+        clippy_in_proc_macro!(
+            self,
+            &attr,
+            NO ID, // Attributes don't have HirIds
+            7
+        );
         lint_callback!(self, check_attribute, attr);
     }
 }
@@ -357,6 +425,8 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>(
         last_node_with_lint_attrs: tcx.hir().local_def_id_to_hir_id(module_def_id),
         generics: None,
         only_module: true,
+        in_proc_macro: false,
+        in_clippy: env::var("CLIPPY_ARGS").is_ok()
     };
 
     // Note: `passes` is often empty. In that case, it's faster to run
@@ -416,6 +486,8 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
         last_node_with_lint_attrs: hir::CRATE_HIR_ID,
         generics: None,
         only_module: false,
+        in_proc_macro: false,
+        in_clippy: env::var("CLIPPY_ARGS").is_ok()
     };
 
     let pass = RuntimeCombinedLateLintPass { passes: &mut passes[..] };

compiler/rustc_lint/src/lib.rs

@@ -34,6 +34,7 @@
 #![feature(iter_intersperse)]
 #![feature(iter_order_by)]
 #![feature(let_chains)]
+#![feature(local_key_cell_methods)]
 #![feature(min_specialization)]
 #![feature(never_type)]
 #![feature(rustc_attrs)]
@@ -64,6 +65,7 @@ pub mod hidden_unicode_codepoints;
 mod internal;
 mod invalid_from_utf8;
 mod late;
+pub mod check_proc_macro;
 mod let_underscore;
 mod levels;
 mod lints;
@@ -135,6 +137,7 @@ pub use passes::{EarlyLintPass, LateLintPass};
 pub use rustc_session::lint::Level::{self, *};
 pub use rustc_session::lint::{BufferedEarlyLint, FutureIncompatibleInfo, Lint, LintId};
 pub use rustc_session::lint::{LintArray, LintPass};
+pub use check_proc_macro::is_from_proc_macro;
 
 fluent_messages! { "../messages.ftl" }
 

src/tools/clippy/clippy_lints/src/allow_attributes.rs

@@ -1,6 +1,6 @@
 use ast::{AttrStyle, Attribute};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_from_proc_macro;
+
 use rustc_ast as ast;
 use rustc_errors::Applicability;
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -58,7 +58,7 @@ impl LateLintPass<'_> for AllowAttribute {
             if let AttrStyle::Outer = attr.style;
             if let Some(ident) = attr.ident();
             if ident.name == rustc_span::symbol::sym::allow;
-            if !is_from_proc_macro(cx, &attr);
+            if !cx.in_proc_macro;
             then {
                 span_lint_and_sugg(
                     cx,