New internal lint: repeated_is_diagnostic_item

ada4a · ada4a · commit 056007510790 · 2025-11-09T20:52:02.000+01:00
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
@@ -227,14 +227,15 @@ impl<'tcx> ImplicitHasherType<'tcx> {
 
             let ty = lower_ty(cx.tcx, hir_ty);
 
-            if ty.is_diag_item(cx, sym::HashMap) && params_len == 2 {
+            let name = ty.opt_diag_name(cx);
+            if name == Some(sym::HashMap) && params_len == 2 {
                 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 {
+            } else if name == Some(sym::HashSet) && params_len == 1 {
                 Some(ImplicitHasherType::HashSet(
                     hir_ty.span,
                     ty,
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
@@ -93,19 +93,19 @@ impl LateLintPass<'_> for UncheckedTimeSubtraction {
         ) = expr.kind
         {
             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)
+                    && rhs_name == Some(sym::Instant)
                     && let Some(sugg) = Sugg::hir_opt(cx, rhs)
                 {
                     print_manual_instant_elapsed_sugg(cx, expr, sugg);
                 }
                 // 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)
                 {
@@ -122,8 +122,8 @@ impl LateLintPass<'_> for UncheckedTimeSubtraction {
                         print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);
                     }
                 }
-            } 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)
             {
@@ -170,7 +170,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<'_>, sugg: Sugg<'_>) {
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_lints_internal/src/internal_paths.rs b/clippy_lints_internal/src/internal_paths.rs
@@ -17,6 +17,7 @@ pub static TY_CTXT: PathLookup = type_path!(rustc_middle::ty::TyCtxt);
 
 // Paths in clippy itself
 pub static CLIPPY_SYM_MODULE: PathLookup = type_path!(clippy_utils::sym);
+pub static MAYBE_DEF: PathLookup = type_path!(clippy_utils::res::MaybeDef);
 pub static MSRV_STACK: PathLookup = type_path!(clippy_utils::msrvs::MsrvStack);
 pub static PATH_LOOKUP_NEW: PathLookup = value_path!(clippy_utils::paths::PathLookup::new);
 pub static SPAN_LINT_AND_THEN: PathLookup = value_path!(clippy_utils::diagnostics::span_lint_and_then);
diff --git a/clippy_lints_internal/src/lib.rs b/clippy_lints_internal/src/lib.rs
@@ -38,6 +38,7 @@ mod lint_without_lint_pass;
 mod msrv_attr_impl;
 mod outer_expn_data_pass;
 mod produce_ice;
+mod repeated_is_diagnostic_item;
 mod symbols;
 mod unnecessary_def_path;
 mod unsorted_clippy_utils_paths;
@@ -77,4 +78,5 @@ pub fn register_lints(store: &mut LintStore) {
     store.register_late_pass(|_| Box::new(msrv_attr_impl::MsrvAttrImpl));
     store.register_late_pass(|_| Box::new(almost_standard_lint_formulation::AlmostStandardFormulation::new()));
     store.register_late_pass(|_| Box::new(unusual_names::UnusualNames));
+    store.register_late_pass(|_| Box::new(repeated_is_diagnostic_item::RepeatedIsDiagnosticItem));
 }
diff --git a/clippy_lints_internal/src/repeated_is_diagnostic_item.rs b/clippy_lints_internal/src/repeated_is_diagnostic_item.rs
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
diff --git a/clippy_utils/src/sym.rs b/clippy_utils/src/sym.rs
diff --git a/tests/ui-internal/repeated_is_diagnostic_item.fixed b/tests/ui-internal/repeated_is_diagnostic_item.fixed
diff --git a/tests/ui-internal/repeated_is_diagnostic_item.rs b/tests/ui-internal/repeated_is_diagnostic_item.rs
diff --git a/tests/ui-internal/repeated_is_diagnostic_item.stderr b/tests/ui-internal/repeated_is_diagnostic_item.stderr
diff --git a/tests/ui-internal/repeated_is_diagnostic_item_unfixable.rs b/tests/ui-internal/repeated_is_diagnostic_item_unfixable.rs
diff --git a/tests/ui-internal/repeated_is_diagnostic_item_unfixable.stderr b/tests/ui-internal/repeated_is_diagnostic_item_unfixable.stderr

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);`