dogfood the lint

ada4a · ada4a · commit 3e55ab1adfd5 · 2025-12-17T12:20:51.000+01:00
This commit is put before the one that actually introduces the lint,
since, were they put in the opposite order, the first commit wouldn't
pass dogfood
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
@@ -433,7 +433,7 @@ fn simplify_not(cx: &LateContext<'_>, curr_msrv: Msrv, expr: &Expr<'_>) -> Optio
         },
         ExprKind::MethodCall(path, receiver, args, _) => {
             let type_of_receiver = cx.typeck_results().expr_ty(receiver);
-            if !type_of_receiver.is_diag_item(cx, sym::Option) && !type_of_receiver.is_diag_item(cx, sym::Result) {
+            if !matches!(type_of_receiver.opt_diag_name(cx), Some(sym::Option | sym::Result)) {
                 return None;
             }
             METHODS_WITH_NEGATION
diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs
@@ -82,7 +82,7 @@ fn lint_impl_body(cx: &LateContext<'_>, item_def_id: hir::OwnerId, impl_span: Sp
             // check for `unwrap`
             if let Some(arglists) = method_chain_args(expr, &[sym::unwrap]) {
                 let receiver_ty = self.typeck_results.expr_ty(arglists[0].0).peel_refs();
-                if receiver_ty.is_diag_item(self.lcx, sym::Option) || receiver_ty.is_diag_item(self.lcx, sym::Result) {
+                if matches!(receiver_ty.opt_diag_name(self.lcx), Some(sym::Option | sym::Result)) {
                     self.result.push(expr.span);
                 }
             }
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
@@ -223,25 +223,20 @@ impl<'tcx> ImplicitHasherType<'tcx> {
                     _ => None,
                 })
                 .collect();
-            let params_len = params.len();
 
             let ty = lower_ty(cx.tcx, hir_ty);
 
-            if ty.is_diag_item(cx, sym::HashMap) && params_len == 2 {
-                Some(ImplicitHasherType::HashMap(
+            match (ty.opt_diag_name(cx), &params[..]) {
+                (Some(sym::HashMap), [k, v]) => Some(ImplicitHasherType::HashMap(
                     hir_ty.span,
                     ty,
-                    snippet(cx, params[0].span, "K"),
-                    snippet(cx, params[1].span, "V"),
-                ))
-            } else if ty.is_diag_item(cx, sym::HashSet) && params_len == 1 {
-                Some(ImplicitHasherType::HashSet(
-                    hir_ty.span,
-                    ty,
-                    snippet(cx, params[0].span, "T"),
-                ))
-            } else {
-                None
+                    snippet(cx, k.span, "K"),
+                    snippet(cx, v.span, "V"),
+                )),
+                (Some(sym::HashSet), [t]) => {
+                    Some(ImplicitHasherType::HashSet(hir_ty.span, ty, snippet(cx, t.span, "T")))
+                },
+                _ => None,
             }
         } else {
             None
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
@@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
             _ => arg,
         };
 
-        if ty.is_diag_item(cx, sym::HashMap) || ty.is_diag_item(cx, sym::BTreeMap) {
+        if matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap)) {
             span_lint_and_then(
                 cx,
                 FOR_KV_MAP,
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
@@ -374,7 +374,7 @@ fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>, check_types: boo
         }
         let ty = typeck_results.pat_ty(pat);
         // Option and Result are allowed, everything else isn't.
-        if !(ty.is_diag_item(cx, sym::Option) || ty.is_diag_item(cx, sym::Result)) {
+        if !matches!(ty.opt_diag_name(cx), Some(sym::Option | sym::Result)) {
             has_disallowed = true;
         }
     });
diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
@@ -16,7 +16,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
     let ty = cx.typeck_results().expr_ty(ex).peel_refs();
     let adt_def = match ty.kind() {
         ty::Adt(adt_def, _)
-            if adt_def.is_enum() && !(ty.is_diag_item(cx, sym::Option) || ty.is_diag_item(cx, sym::Result)) =>
+            if adt_def.is_enum() && !matches!(ty.opt_diag_name(cx), Some(sym::Option | sym::Result)) =>
         {
             adt_def
         },
diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs
@@ -26,12 +26,10 @@ pub(super) fn check<'tcx>(
     let arg_root = get_arg_root(cx, arg);
     if contains_call(cx, arg_root) && !contains_return(arg_root) {
         let receiver_type = cx.typeck_results().expr_ty_adjusted(receiver);
-        let closure_args = if receiver_type.is_diag_item(cx, sym::Option) {
-            "||"
-        } else if receiver_type.is_diag_item(cx, sym::Result) {
-            "|_|"
-        } else {
-            return;
+        let closure_args = match receiver_type.opt_diag_name(cx) {
+            Some(sym::Option) => "||",
+            Some(sym::Result) => "|_|",
+            _ => return,
         };
 
         let span_replace_word = method_span.with_hi(expr.span.hi());
diff --git a/clippy_lints/src/methods/iter_count.rs b/clippy_lints/src/methods/iter_count.rs
@@ -11,26 +11,17 @@ use super::ITER_COUNT;
 
 pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx Expr<'tcx>, iter_method: Symbol) {
     let ty = cx.typeck_results().expr_ty(recv);
-    let caller_type = if derefs_to_slice(cx, recv, ty).is_some() {
-        "slice"
-    } else if ty.is_diag_item(cx, sym::Vec) {
-        "Vec"
-    } else if ty.is_diag_item(cx, sym::VecDeque) {
-        "VecDeque"
-    } else if ty.is_diag_item(cx, sym::HashSet) {
-        "HashSet"
-    } else if ty.is_diag_item(cx, sym::HashMap) {
-        "HashMap"
-    } else if ty.is_diag_item(cx, sym::BTreeMap) {
-        "BTreeMap"
-    } else if ty.is_diag_item(cx, sym::BTreeSet) {
-        "BTreeSet"
-    } else if ty.is_diag_item(cx, sym::LinkedList) {
-        "LinkedList"
-    } else if ty.is_diag_item(cx, sym::BinaryHeap) {
-        "BinaryHeap"
-    } else {
-        return;
+    let caller_type = match ty.opt_diag_name(cx) {
+        _ if derefs_to_slice(cx, recv, ty).is_some() => "slice",
+        Some(sym::Vec) => "Vec",
+        Some(sym::VecDeque) => "VecDeque",
+        Some(sym::HashSet) => "HashSet",
+        Some(sym::HashMap) => "HashMap",
+        Some(sym::BTreeMap) => "BTreeMap",
+        Some(sym::BTreeSet) => "BTreeSet",
+        Some(sym::LinkedList) => "LinkedList",
+        Some(sym::BinaryHeap) => "BinaryHeap",
+        _ => return,
     };
     let mut applicability = Applicability::MachineApplicable;
     span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
@@ -38,7 +38,7 @@ pub(super) fn check<'tcx>(
             _ => return,
         }
         && let ty = cx.typeck_results().expr_ty_adjusted(recv).peel_refs()
-        && (ty.is_diag_item(cx, sym::HashMap) || ty.is_diag_item(cx, sym::BTreeMap))
+        && matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap))
     {
         let mut applicability = rustc_errors::Applicability::MachineApplicable;
         let recv_snippet = snippet_with_applicability(cx, recv.span, "map", &mut applicability);
diff --git a/clippy_lints/src/methods/join_absolute_paths.rs b/clippy_lints/src/methods/join_absolute_paths.rs
@@ -13,7 +13,7 @@ use super::JOIN_ABSOLUTE_PATHS;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx Expr<'tcx>, join_arg: &'tcx Expr<'tcx>, expr_span: Span) {
     let ty = cx.typeck_results().expr_ty(recv).peel_refs();
-    if (ty.is_diag_item(cx, sym::Path) || ty.is_diag_item(cx, sym::PathBuf))
+    if matches!(ty.opt_diag_name(cx), Some(sym::Path | sym::PathBuf))
         && let ExprKind::Lit(spanned) = expr_or_init(cx, join_arg).kind
         && let LitKind::Str(symbol, _) = spanned.node
         && let sym_str = symbol.as_str()
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
@@ -25,7 +25,7 @@ fn should_run_lint(cx: &LateContext<'_>, e: &hir::Expr<'_>, method_parent_id: De
     }
     // We check if it's an `Option` or a `Result`.
     if let Some(ty) = method_parent_id.opt_impl_ty(cx) {
-        if !ty.is_diag_item(cx, sym::Option) && !ty.is_diag_item(cx, sym::Result) {
+        if !matches!(ty.opt_diag_name(cx), Some(sym::Option | sym::Result)) {
             return false;
         }
     } else {
diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -20,24 +20,28 @@ pub(super) fn check<'tcx>(
     let title;
     let or_arg_content: Span;
 
-    if ty.is_diag_item(cx, sym::Option) {
-        title = "found `.or(Some(…)).unwrap()`";
-        if let Some(content) = get_content_if_ctor_matches(cx, or_arg, LangItem::OptionSome) {
-            or_arg_content = content;
-        } else {
+    match ty.opt_diag_name(cx) {
+        Some(sym::Option) => {
+            title = "found `.or(Some(…)).unwrap()`";
+            if let Some(content) = get_content_if_ctor_matches(cx, or_arg, LangItem::OptionSome) {
+                or_arg_content = content;
+            } else {
+                return;
+            }
+        },
+        Some(sym::Result) => {
+            title = "found `.or(Ok(…)).unwrap()`";
+            if let Some(content) = get_content_if_ctor_matches(cx, or_arg, LangItem::ResultOk) {
+                or_arg_content = content;
+            } else {
+                return;
+            }
+        },
+        _ => {
+            // Someone has implemented a struct with .or(...).unwrap() chaining,
+            // but it's not an Option or a Result, so bail
             return;
-        }
-    } else if ty.is_diag_item(cx, sym::Result) {
-        title = "found `.or(Ok(…)).unwrap()`";
-        if let Some(content) = get_content_if_ctor_matches(cx, or_arg, LangItem::ResultOk) {
-            or_arg_content = content;
-        } else {
-            return;
-        }
-    } else {
-        // Someone has implemented a struct with .or(...).unwrap() chaining,
-        // but it's not an Option or a Result, so bail
-        return;
+        },
     }
 
     let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/methods/unnecessary_get_then_check.rs b/clippy_lints/src/methods/unnecessary_get_then_check.rs
@@ -11,11 +11,11 @@ use rustc_span::{Span, sym};
 use super::UNNECESSARY_GET_THEN_CHECK;
 
 fn is_a_std_set_type(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    ty.is_diag_item(cx, sym::HashSet) || ty.is_diag_item(cx, sym::BTreeSet)
+    matches!(ty.opt_diag_name(cx), Some(sym::HashSet | sym::BTreeSet))
 }
 
 fn is_a_std_map_type(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    ty.is_diag_item(cx, sym::HashMap) || ty.is_diag_item(cx, sym::BTreeMap)
+    matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap))
 }
 
 pub(super) fn check(
diff --git a/clippy_lints/src/methods/unwrap_expect_used.rs b/clippy_lints/src/methods/unwrap_expect_used.rs
@@ -46,19 +46,19 @@ pub(super) fn check(
 ) {
     let ty = cx.typeck_results().expr_ty(recv).peel_refs();
 
-    let (kind, none_value, none_prefix) = if ty.is_diag_item(cx, sym::Option) && !is_err {
-        ("an `Option`", "None", "")
-    } else if ty.is_diag_item(cx, sym::Result)
-        && let ty::Adt(_, substs) = ty.kind()
-        && let Some(t_or_e_ty) = substs[usize::from(!is_err)].as_type()
-    {
-        if is_never_like(t_or_e_ty) {
-            return;
-        }
+    let (kind, none_value, none_prefix) = match ty.opt_diag_name(cx) {
+        Some(sym::Option) if !is_err => ("an `Option`", "None", ""),
+        Some(sym::Result)
+            if let ty::Adt(_, substs) = ty.kind()
+                && let Some(t_or_e_ty) = substs[usize::from(!is_err)].as_type() =>
+        {
+            if is_never_like(t_or_e_ty) {
+                return;
+            }
 
-        ("a `Result`", if is_err { "Ok" } else { "Err" }, "an ")
-    } else {
-        return;
+            ("a `Result`", if is_err { "Ok" } else { "Err" }, "an ")
+        },
+        _ => return,
     };
 
     let method_suffix = if is_err { "_err" } else { "" };
diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
@@ -112,10 +112,14 @@ fn should_lint<'tcx>(
         if let ExprKind::MethodCall(path, recv, ..) = &expr.kind {
             let recv_ty = typeck_results.expr_ty(recv).peel_refs();
 
-            if path.ident.name == sym::debug_struct && recv_ty.is_diag_item(cx, sym::Formatter) {
-                has_debug_struct = true;
-            } else if path.ident.name == sym::finish_non_exhaustive && recv_ty.is_diag_item(cx, sym::DebugStruct) {
-                has_finish_non_exhaustive = true;
+            match (path.ident.name, recv_ty.opt_diag_name(cx)) {
+                (sym::debug_struct, Some(sym::Formatter)) => {
+                    has_debug_struct = true;
+                },
+                (sym::finish_non_exhaustive, Some(sym::DebugStruct)) => {
+                    has_finish_non_exhaustive = true;
+                },
+                _ => {},
             }
         }
         ControlFlow::<!, _>::Continue(())
diff --git a/clippy_lints/src/time_subtraction.rs b/clippy_lints/src/time_subtraction.rs
@@ -91,25 +91,25 @@ impl LateLintPass<'_> for UncheckedTimeSubtraction {
             _ => return,
         };
         let typeck = cx.typeck_results();
-        let lhs_ty = typeck.expr_ty(lhs);
-        let rhs_ty = typeck.expr_ty(rhs);
+        let lhs_name = typeck.expr_ty(lhs).opt_diag_name(cx);
+        let rhs_name = typeck.expr_ty(rhs).opt_diag_name(cx);
 
-        if lhs_ty.is_diag_item(cx, sym::Instant) {
+        if lhs_name == Some(sym::Instant) {
             // Instant::now() - instant
-            if is_instant_now_call(cx, lhs) && rhs_ty.is_diag_item(cx, sym::Instant) {
+            if is_instant_now_call(cx, lhs) && rhs_name == Some(sym::Instant) {
                 print_manual_instant_elapsed_sugg(cx, expr, rhs);
             }
             // instant - duration
-            else if rhs_ty.is_diag_item(cx, sym::Duration)
+            else if rhs_name == Some(sym::Duration)
                 && !expr.span.from_expansion()
                 && self.msrv.meets(cx, msrvs::TRY_FROM)
             {
                 print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);
             }
         }
         // duration - duration
-        else if lhs_ty.is_diag_item(cx, sym::Duration)
-            && rhs_ty.is_diag_item(cx, sym::Duration)
+        else if lhs_name == Some(sym::Duration)
+            && rhs_name == Some(sym::Duration)
             && !expr.span.from_expansion()
             && self.msrv.meets(cx, msrvs::TRY_FROM)
         {
@@ -144,7 +144,7 @@ fn is_chained_time_subtraction(cx: &LateContext<'_>, lhs: &Expr<'_>) -> bool {
 
 /// Returns true if the type is Duration or Instant
 fn is_time_type(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    ty.is_diag_item(cx, sym::Duration) || ty.is_diag_item(cx, sym::Instant)
+    matches!(ty.opt_diag_name(cx), Some(sym::Duration | sym::Instant))
 }
 
 fn print_manual_instant_elapsed_sugg(cx: &LateContext<'_>, expr: &Expr<'_>, rhs: &Expr<'_>) {
diff --git a/clippy_lints/src/zero_sized_map_values.rs b/clippy_lints/src/zero_sized_map_values.rs
@@ -49,7 +49,7 @@ impl LateLintPass<'_> for ZeroSizedMapValues {
             && !in_trait_impl(cx, hir_ty.hir_id)
             // We don't care about infer vars
             && let ty = ty_from_hir_ty(cx, hir_ty.as_unambig_ty())
-            && (ty.is_diag_item(cx, sym::HashMap) || ty.is_diag_item(cx, sym::BTreeMap))
+            && matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap))
             && let ty::Adt(_, args) = ty.kind()
             && let ty = args.type_at(1)
             // Ensure that no type information is missing, to avoid a delayed bug in the compiler if this is not the case.
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
@@ -809,10 +809,12 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                                 | sym::i128_legacy_const_max
                         )
                     ) || self.tcx.opt_parent(did).is_some_and(|parent| {
-                        parent.is_diag_item(&self.tcx, sym::f16_consts_mod)
-                            || parent.is_diag_item(&self.tcx, sym::f32_consts_mod)
-                            || parent.is_diag_item(&self.tcx, sym::f64_consts_mod)
-                            || parent.is_diag_item(&self.tcx, sym::f128_consts_mod)
+                        matches!(
+                            parent.opt_diag_name(&self.tcx),
+                            Some(
+                                sym::f16_consts_mod | sym::f32_consts_mod | sym::f64_consts_mod | sym::f128_consts_mod
+                            )
+                        )
                     })) =>
             {
                 did
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
@@ -58,6 +58,7 @@ generate! {
     LowerHex,
     MAX,
     MIN,
+    MaybeDef,
     MsrvStack,
     Octal,
     OpenOptions,
@@ -192,6 +193,8 @@ generate! {
     io,
     is_ascii,
     is_char_boundary,
+    is_diag_item,
+    is_diagnostic_item,
     is_digit,
     is_empty,
     is_err,
@@ -283,6 +286,7 @@ generate! {
     repeat,
     replace,
     replacen,
+    res,
     reserve,
     resize,
     restriction,

Original file line number	Diff line number	Diff line change
`@@ -433,7 +433,7 @@ fn simplify_not(cx: &LateContext<'_>, curr_msrv: Msrv, expr: &Expr<'_>) -> Optio`
`433`	`433`	`},`
`434`	`434`	`ExprKind::MethodCall(path, receiver, args, _) => {`
`435`	`435`	`let type_of_receiver = cx.typeck_results().expr_ty(receiver);`
`436`		`- if !type_of_receiver.is_diag_item(cx, sym::Option) && !type_of_receiver.is_diag_item(cx, sym::Result) {`
	`436`	`+ if !matches!(type_of_receiver.opt_diag_name(cx), Some(sym::Option \| sym::Result)) {`
`437`	`437`	`return None;`
`438`	`438`	`}`
`439`	`439`	`METHODS_WITH_NEGATION`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ fn lint_impl_body(cx: &LateContext<'_>, item_def_id: hir::OwnerId, impl_span: Sp`
`82`	`82`	// check for `unwrap`
`83`	`83`	`if let Some(arglists) = method_chain_args(expr, &[sym::unwrap]) {`
`84`	`84`	`let receiver_ty = self.typeck_results.expr_ty(arglists[0].0).peel_refs();`
`85`		`- if receiver_ty.is_diag_item(self.lcx, sym::Option) \|\| receiver_ty.is_diag_item(self.lcx, sym::Result) {`
	`85`	`+ if matches!(receiver_ty.opt_diag_name(self.lcx), Some(sym::Option \| sym::Result)) {`
`86`	`86`	`self.result.push(expr.span);`
`87`	`87`	`}`
`88`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -374,7 +374,7 @@ fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>, check_types: boo`
`374`	`374`	`}`
`375`	`375`	`let ty = typeck_results.pat_ty(pat);`
`376`	`376`	`// Option and Result are allowed, everything else isn't.`
`377`		`- if !(ty.is_diag_item(cx, sym::Option) \|\| ty.is_diag_item(cx, sym::Result)) {`
	`377`	`+ if !matches!(ty.opt_diag_name(cx), Some(sym::Option \| sym::Result)) {`
`378`	`378`	`has_disallowed = true;`
`379`	`379`	`}`
`380`	`380`	`});`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {`
`16`	`16`	`let ty = cx.typeck_results().expr_ty(ex).peel_refs();`
`17`	`17`	`let adt_def = match ty.kind() {`
`18`	`18`	`ty::Adt(adt_def, _)`
`19`		`- if adt_def.is_enum() && !(ty.is_diag_item(cx, sym::Option) \|\| ty.is_diag_item(cx, sym::Result)) =>`
	`19`	`+ if adt_def.is_enum() && !matches!(ty.opt_diag_name(cx), Some(sym::Option \| sym::Result)) =>`
`20`	`20`	`{`
`21`	`21`	`adt_def`
`22`	`22`	`},`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ pub(super) fn check<'tcx>(`
`38`	`38`	`_ => return,`
`39`	`39`	`}`
`40`	`40`	`&& let ty = cx.typeck_results().expr_ty_adjusted(recv).peel_refs()`
`41`		`- && (ty.is_diag_item(cx, sym::HashMap) \|\| ty.is_diag_item(cx, sym::BTreeMap))`
	`41`	`+ && matches!(ty.opt_diag_name(cx), Some(sym::HashMap \| sym::BTreeMap))`
`42`	`42`	`{`
`43`	`43`	`let mut applicability = rustc_errors::Applicability::MachineApplicable;`
`44`	`44`	`let recv_snippet = snippet_with_applicability(cx, recv.span, "map", &mut applicability);`