Make it only lint crate/<crate>

Author: Centri3

clippy_lints/src/absolute_symbol_paths.rs

@@ -1,12 +1,12 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_from_proc_macro;
-use rustc_hir::intravisit::{walk_qpath, Visitor};
-use rustc_hir::{def_id::LOCAL_CRATE, HirId, QPath};
+use clippy_utils::source::snippet_opt;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
+use rustc_hir::{HirId, ItemKind, Node, Path};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::Span;
-use std::iter::once;
+use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -37,83 +37,53 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.72.0"]
     pub ABSOLUTE_SYMBOL_PATHS,
-    style,
+    restriction,
     "checks for usage of a symbol without a `use` statement"
 }
 impl_lint_pass!(AbsoluteSymbolPaths => [ABSOLUTE_SYMBOL_PATHS]);
 
 pub struct AbsoluteSymbolPaths {
     pub absolute_symbol_paths_max_segments: u64,
-    pub absolute_symbol_paths_allow_std: bool,
+    pub absolute_symbol_paths_allowed_crates: FxHashSet<String>,
 }
 
 impl LateLintPass<'_> for AbsoluteSymbolPaths {
-    fn check_crate(&mut self, cx: &LateContext<'_>) {
-        let Self {
-            absolute_symbol_paths_max_segments,
-            absolute_symbol_paths_allow_std,
-        } = *self;
-
-        cx.tcx.hir().visit_all_item_likes_in_crate(&mut V {
-            cx,
-            absolute_symbol_paths_max_segments,
-            absolute_symbol_paths_allow_std,
-        });
-    }
-}
-
-struct V<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    absolute_symbol_paths_max_segments: u64,
-    absolute_symbol_paths_allow_std: bool,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for V<'a, 'tcx> {
-    type NestedFilter = OnlyBodies;
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-
+    // We should only lint `QPath::Resolved`s, but since `Path` is only used in `Resolved` and `UsePath`
+    // we don't need to use a visitor or anything as we can just check if the `Node` for `hir_id` isn't
+    // a `Use`
     #[expect(clippy::cast_possible_truncation)]
-    fn visit_qpath(&mut self, qpath: &'tcx QPath<'tcx>, hir_id: HirId, span: Span) {
+    fn check_path(&mut self, cx: &LateContext<'_>, path: &Path<'_>, hir_id: HirId) {
         let Self {
-            cx,
             absolute_symbol_paths_max_segments,
-            absolute_symbol_paths_allow_std,
-        } = *self;
+            absolute_symbol_paths_allowed_crates,
+        } = self;
 
-        if !span.from_expansion()
-            && let QPath::Resolved(_, path) = qpath
-            && let Some(def_id) = path.res.opt_def_id()
-            && let def_path = cx.tcx.def_path(def_id)
-            && let crate_name = cx.tcx.crate_name(def_path.krate)
-            && let segments = once(crate_name)
-                .chain(def_path.data.iter().filter_map(|segment| segment.data.get_opt_name()))
-            && path.segments.len() > absolute_symbol_paths_max_segments as usize
-            && let is_std = matches!(crate_name.as_str(), "alloc" | "core" | "std")
-            && !(absolute_symbol_paths_allow_std && is_std)
-            // If this is local, keep the crate name, if it is not, remove it, as we don't need to
-            // check that (and results in FNs on reexports from one crate to another)
-            //
-            // `def_path_str` handles this for us, but unfortunately requires converting every
-            // `Symbol` to a `&str`, which is a very slow operation.
-            && segments.skip(1).eq(
-                path.segments.iter()
-                    // I love clippy :)
-                    .skip(usize::from(def_path.krate != LOCAL_CRATE))
-                    .map(|segment| segment.ident.name)
-                )
-            && !is_from_proc_macro(cx, qpath)
+        if !path.span.from_expansion()
+            && let Some(node) = cx.tcx.hir().find(hir_id)
+            && !matches!(node, Node::Item(item) if matches!(item.kind, ItemKind::Use(_, _)))
+            && path.segments.len() > *absolute_symbol_paths_max_segments as usize
+            && let [first, ..] = path.segments
+            && let Some(first_snippet) = snippet_opt(cx, first.ident.span)
+            && first_snippet == first.ident.as_str()
         {
-            span_lint(
-                cx,
-                ABSOLUTE_SYMBOL_PATHS,
-                span,
-                "consider referring to this symbol by adding a `use` statement for consistent formatting",
-            );
-        }
+            let is_abs_external =
+                matches!(first.res, Res::Def(DefKind::Mod, DefId { index, .. }) if index == CRATE_DEF_INDEX);
+            let is_abs_crate = first.ident.name == kw::Crate;
+
+            if is_abs_external && absolute_symbol_paths_allowed_crates.contains(first.ident.name.as_str())
+                || is_abs_crate && absolute_symbol_paths_allowed_crates.contains("crate")
+            {
+                return;
+            }
 
-        walk_qpath(self, qpath, hir_id);
+            if is_abs_external || is_abs_crate {
+                span_lint(
+                    cx,
+                    ABSOLUTE_SYMBOL_PATHS,
+                    path.span,
+                    "consider referring to this symbol by adding a `use` statement for consistent formatting",
+                );
+            }
+        }
     }
 }

clippy_lints/src/lib.rs

@@ -1086,11 +1086,11 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     store.register_late_pass(move |_| Box::new(tuple_array_conversions::TupleArrayConversions { msrv: msrv() }));
     store.register_late_pass(|_| Box::new(manual_float_methods::ManualFloatMethods));
     let absolute_symbol_paths_max_segments = conf.absolute_symbol_paths_max_segments;
-    let absolute_symbol_paths_allow_std = conf.absolute_symbol_paths_allow_std;
+    let absolute_symbol_paths_allowed_crates = conf.absolute_symbol_paths_allowed_crates.clone();
     store.register_late_pass(move |_| {
         Box::new(absolute_symbol_paths::AbsoluteSymbolPaths {
             absolute_symbol_paths_max_segments,
-            absolute_symbol_paths_allow_std,
+            absolute_symbol_paths_allowed_crates: absolute_symbol_paths_allowed_crates.clone(),
         })
     });
     // add lints here, do not remove this comment, it's used in `new_lint`

clippy_lints/src/utils/conf.rs

@@ -557,8 +557,9 @@ define_Conf! {
     (absolute_symbol_paths_max_segments: u64 = 3),
     /// Lint: ABSOLUTE_SYMBOL_PATHS.
     ///
-    /// Whether to allow paths originating from `core`/`std`/`alloc`
-    (absolute_symbol_paths_allow_std: bool = false),
+    /// Which crates to allow absolute symbols, `crate` will allow the local crate
+    (absolute_symbol_paths_allowed_crates: rustc_data_structures::fx::FxHashSet<String> =
+        rustc_data_structures::fx::FxHashSet::default()),
 }
 
 /// Search for the configuration file.

clippy_utils/src/check_proc_macro.rs

@@ -304,7 +304,7 @@ fn attr_search_pat(attr: &Attribute) -> (Pat, Pat) {
         },
         AttrKind::DocComment(_kind @ CommentKind::Line, ..) => {
             if matches!(attr.style, AttrStyle::Outer) {
-                (Pat::Str("///*"), Pat::Str(""))
+                (Pat::Str("///"), Pat::Str(""))
             } else {
                 (Pat::Str("//!"), Pat::Str(""))
             }

clippy_utils/src/usage.rs

@@ -155,7 +155,9 @@ pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
 }
 
 pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr<'_>) -> bool {
-    let Some(block) = utils::get_enclosing_block(cx, local_id) else { return false };
+    let Some(block) = utils::get_enclosing_block(cx, local_id) else {
+        return false;
+    };
 
     // for _ in 1..3 {
     //    local

tests/ui-toml/absolute_symbol_paths/absolute_symbol_paths.allow_crates.stderr

@@ -0,0 +1,16 @@
+error: consider referring to this symbol by adding a `use` statement for consistent formatting
+  --> $DIR/absolute_symbol_paths.rs:40:5
+   |
+LL |     std::f32::MAX;
+   |     ^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::absolute-symbol-paths` implied by `-D warnings`
+
+error: consider referring to this symbol by adding a `use` statement for consistent formatting
+  --> $DIR/absolute_symbol_paths.rs:41:5
+   |
+LL |     core::f32::MAX;
+   |     ^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+

tests/ui-toml/absolute_symbol_paths/absolute_symbol_paths.allow_std.stderr

@@ -1,46 +1,52 @@
 error: consider referring to this symbol by adding a `use` statement for consistent formatting
-  --> $DIR/absolute_symbol_paths.rs:38:5
+  --> $DIR/absolute_symbol_paths.rs:40:5
    |
 LL |     std::f32::MAX;
    |     ^^^^^^^^^^^^^
    |
    = note: `-D clippy::absolute-symbol-paths` implied by `-D warnings`
 
 error: consider referring to this symbol by adding a `use` statement for consistent formatting
-  --> $DIR/absolute_symbol_paths.rs:39:5
+  --> $DIR/absolute_symbol_paths.rs:41:5
    |
 LL |     core::f32::MAX;
    |     ^^^^^^^^^^^^^^
 
 error: consider referring to this symbol by adding a `use` statement for consistent formatting
-  --> $DIR/absolute_symbol_paths.rs:40:5
+  --> $DIR/absolute_symbol_paths.rs:42:5
    |
-LL |     a::b::c::C;
-   |     ^^^^^^^^^^
+LL |     crate::a::b::c::C;
+   |     ^^^^^^^^^^^^^^^^^
 
 error: consider referring to this symbol by adding a `use` statement for consistent formatting
-  --> $DIR/absolute_symbol_paths.rs:41:5
+  --> $DIR/absolute_symbol_paths.rs:43:5
    |
-LL |     a::b::c::d::e::f::F;
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |     crate::a::b::c::d::e::f::F;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider referring to this symbol by adding a `use` statement for consistent formatting
-  --> $DIR/absolute_symbol_paths.rs:43:5
+  --> $DIR/absolute_symbol_paths.rs:44:5
    |
-LL |     a::b::B;
-   |     ^^^^^^^
+LL |     crate::a::A;
+   |     ^^^^^^^^^^^
 
 error: consider referring to this symbol by adding a `use` statement for consistent formatting
-  --> $DIR/absolute_symbol_paths.rs:44:5
+  --> $DIR/absolute_symbol_paths.rs:45:5
+   |
+LL |     crate::a::b::B;
+   |     ^^^^^^^^^^^^^^
+
+error: consider referring to this symbol by adding a `use` statement for consistent formatting
+  --> $DIR/absolute_symbol_paths.rs:46:5
    |
-LL |     a::b::c::C::ZERO;
-   |     ^^^^^^^^^^
+LL |     crate::a::b::c::C::ZERO;
+   |     ^^^^^^^^^^^^^^^^^
 
 error: consider referring to this symbol by adding a `use` statement for consistent formatting
-  --> $DIR/absolute_symbol_paths.rs:45:15
+  --> $DIR/absolute_symbol_paths.rs:47:5
    |
-LL |     fn b() -> a::b::B {
-   |               ^^^^^^^
+LL |     helper::b::c::d::e::f();
+   |     ^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: aborting due to 8 previous errors
 

tests/ui-toml/absolute_symbol_paths/absolute_symbol_paths.disallow_std.stderr renamed to tests/ui-toml/absolute_symbol_paths/absolute_symbol_paths.disallow_crates.stderr

@@ -1,11 +1,13 @@
 //@aux-build:../../ui/auxiliary/proc_macros.rs:proc-macro
-//@revisions: allow_std disallow_std
-//@[allow_std] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_symbol_paths/allow_std
-//@[disallow_std] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_symbol_paths/disallow_std
+//@aux-build:helper.rs
+//@revisions: allow_crates disallow_crates
+//@[allow_crates] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_symbol_paths/allow_crates
+//@[disallow_crates] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_symbol_paths/disallow_crates
 #![allow(clippy::no_effect, unused)]
 #![warn(clippy::absolute_symbol_paths)]
 #![feature(decl_macro)]
 
+extern crate helper;
 #[macro_use]
 extern crate proc_macros;
 
@@ -37,17 +39,24 @@ fn main() {
     f32::max(1.0, 2.0);
     std::f32::MAX;
     core::f32::MAX;
-    a::b::c::C;
-    a::b::c::d::e::f::F;
-    a::A;
-    a::b::B;
-    a::b::c::C::ZERO;
+    crate::a::b::c::C;
+    crate::a::b::c::d::e::f::F;
+    crate::a::A;
+    crate::a::b::B;
+    crate::a::b::c::C::ZERO;
+    helper::b::c::d::e::f();
     fn b() -> a::b::B {
         todo!()
     }
-    // Does not lint
+    std::println!("a");
+    let x = 1;
+    std::ptr::addr_of!(x);
+    // Do not lint
+    helper::a();
+    use crate::a::b::c::C;
     use a::b;
-    use a::b::c::C;
+    use std::f32::MAX;
+    a::b::c::d::e::f::F;
     b::c::C;
     fn a() -> a::A {
         todo!()
@@ -61,25 +70,21 @@ fn main() {
         todo!()
     }
     external! {
-        a::b::c::C::ZERO;
+        crate::a::b::c::C::ZERO;
     }
+    // For some reason, `path.span.from_expansion()` takes care of this for us
     with_span! {
         span
-        a::b::c::C::ZERO;
+        crate::a::b::c::C::ZERO;
     }
     macro_rules! local_crate {
         () => {
-            a::b::c::C::ZERO;
+            crate::a::b::c::C::ZERO;
         };
     }
     macro local_crate_2_0() {
-        a::b::c::C::ZERO;
+        crate::a::b::c::C::ZERO;
     }
     local_crate!();
     local_crate_2_0!();
-    // Macros are unfortunately tricky, as these are defined in `std::macros` but we have to access
-    // them from `std::println!`, both due to privacy and because they're not macros 2.0
-    std::println!("a");
-    let x = 1;
-    std::ptr::addr_of!(x);
 }

tests/ui-toml/absolute_symbol_paths/absolute_symbol_paths.rs

@@ -0,0 +1,2 @@
+absolute-symbol-paths-max-segments = 2
+absolute-symbol-paths-allowed-crates = ["crate", "helper"]