impl

Author: Jarcho

clippy_lints/src/absolute_paths.rs

@@ -64,24 +64,37 @@ impl<'tcx> LateLintPass<'tcx> for AbsolutePaths {
     // 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`
     fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, hir_id: HirId) {
-        let (first, len) = match path.segments {
-            // Any path starting with `::` must have the second segment refer to an external crate.
-            // Make sure not to include the `::` segment when counting the segments.
-            [root, first, ..] if root.ident.name == kw::PathRoot => (first, path.segments.len() - 1),
-            [first, _, ..]
-                if first.ident.name == kw::Crate
-                    || matches!(first.res, Res::Def(DefKind::Mod, DefId { index, .. }) if index == CRATE_DEF_INDEX) =>
+        let segments = match path.segments {
+            [] | [_] => return,
+            // Don't count enum variants and trait items as part of the length.
+            [rest @ .., _]
+                if let [.., s] = rest
+                    && matches!(s.res, Res::Def(DefKind::Enum | DefKind::Trait | DefKind::TraitAlias, _)) =>
             {
-                (first, path.segments.len())
+                rest
             },
-            _ => return,
+            path => path,
         };
-
-        if len as u64 > self.absolute_paths_max_segments
+        if let [s1, s2, ..] = segments
+            && let has_root = s1.ident.name == kw::PathRoot
+            && let first = if has_root { s2 } else { s1 }
+            && let len = segments.len() - usize::from(has_root)
+            && len as u64 > self.absolute_paths_max_segments
+            && let crate_name = if let Res::Def(DefKind::Mod, DefId { index, .. }) = first.res
+                && index == CRATE_DEF_INDEX
+            {
+                // `other_crate::foo` or `::other_crate::foo`
+                first.ident.name
+            } else if first.ident.name == kw::Crate || has_root {
+                // `::foo` or `crate::foo`
+                kw::Crate
+            } else {
+                return;
+            }
             && !path.span.from_expansion()
             && let node = cx.tcx.hir_node(hir_id)
             && !matches!(node, Node::Item(item) if matches!(item.kind, ItemKind::Use(..)))
-            && !self.absolute_paths_allowed_crates.contains(&first.ident.name)
+            && !self.absolute_paths_allowed_crates.contains(&crate_name)
             && !is_from_proc_macro(cx, path)
         {
             span_lint(

clippy_utils/src/check_proc_macro.rs

@@ -123,16 +123,14 @@ fn qpath_search_pat(path: &QPath<'_>) -> (Pat, Pat) {
 
 fn path_search_pat(path: &Path<'_>) -> (Pat, Pat) {
     let (head, tail) = match path.segments {
-        [head, .., tail] => (head, tail),
-        [p] => (p, p),
         [] => return (Pat::Str(""), Pat::Str("")),
+        [p] => (Pat::Sym(p.ident.name), p),
+        // QPath::Resolved can have a path that looks like `<Foo as Bar>::baz` where
+        // the path (`Bar::baz`) has it's span covering the whole QPath.
+        [.., tail] => (Pat::Str(""), tail),
     };
     (
-        if head.ident.name == kw::PathRoot {
-            Pat::Str("::")
-        } else {
-            Pat::Sym(head.ident.name)
-        },
+        head,
         if tail.args.is_some() {
             Pat::Str(">")
         } else {