diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 08253b0c4995..2bbd5dff2919 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -3,9 +3,8 @@ use clippy_utils::macros::{PanicExpn, find_assert_args, root_macro_call_first_no
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{has_debug_impl, is_copy, is_type_diagnostic_item};
 use clippy_utils::usage::local_used_after_expr;
-use clippy_utils::{path_res, sym};
+use clippy_utils::{path_to_local, sym};
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, Ty};
@@ -61,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
             if !is_copy(cx, result_type) {
                 if result_type_with_refs != result_type {
                     return;
-                } else if let Res::Local(binding_id) = path_res(cx, recv)
+                } else if let Some(binding_id) = path_to_local(recv)
                     && local_used_after_expr(cx, binding_id, recv)
                 {
                     return;
diff --git a/clippy_lints/src/box_default.rs b/clippy_lints/src/box_default.rs
index 3b861848f94a..e7f16b2522ea 100644
--- a/clippy_lints/src/box_default.rs
+++ b/clippy_lints/src/box_default.rs
@@ -1,11 +1,12 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_default_equivalent;
 use clippy_utils::macros::macro_backtrace;
+use clippy_utils::res::PathRes;
 use clippy_utils::ty::expr_sig;
-use clippy_utils::{is_default_equivalent, path_def_id};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{InferKind, Visitor, VisitorExt, walk_ty};
-use rustc_hir::{AmbigArg, Block, Expr, ExprKind, HirId, LetStmt, Node, QPath, Ty, TyKind};
+use rustc_hir::{AmbigArg, Block, Expr, ExprKind, HirId, LangItem, LetStmt, Node, QPath, Ty, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::declare_lint_pass;
 use rustc_span::{Span, sym};
@@ -44,7 +45,7 @@ impl LateLintPass<'_> for BoxDefault {
             // And that method is `new`
             && seg.ident.name == sym::new
             // And the call is that of a `Box` method
-            && path_def_id(cx, ty).is_some_and(|id| Some(id) == cx.tcx.lang_items().owned_box())
+            && cx.is_path_lang_item(ty, LangItem::OwnedBox)
             // And the single argument to the call is another function call
             // This is the `T::default()` (or default equivalent) of `Box::new(T::default())`
             && let ExprKind::Call(arg_path, _) = arg.kind
diff --git a/clippy_lints/src/casts/manual_dangling_ptr.rs b/clippy_lints/src/casts/manual_dangling_ptr.rs
index 92910cf8adf5..7ed0e18b155d 100644
--- a/clippy_lints/src/casts/manual_dangling_ptr.rs
+++ b/clippy_lints/src/casts/manual_dangling_ptr.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::SpanRangeExt;
-use clippy_utils::{expr_or_init, is_path_diagnostic_item, std_or_core, sym};
+use clippy_utils::{expr_or_init, std_or_core, sym};
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, GenericArg, Mutability, QPath, Ty, TyKind};
@@ -52,8 +52,11 @@ fn is_expr_const_aligned(cx: &LateContext<'_>, expr: &Expr<'_>, to: &Ty<'_>) ->
 }
 
 fn is_align_of_call(cx: &LateContext<'_>, fun: &Expr<'_>, to: &Ty<'_>) -> bool {
-    if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind
-        && is_path_diagnostic_item(cx, fun, sym::mem_align_of)
+    if let ExprKind::Path(QPath::Resolved(None, path)) = fun.kind
+        && path
+            .res
+            .opt_def_id()
+            .is_some_and(|did| cx.tcx.is_diagnostic_item(sym::mem_align_of, did))
         && let Some(args) = path.segments.last().and_then(|seg| seg.args)
         && let [GenericArg::Type(generic_ty)] = args.args
     {
diff --git a/clippy_lints/src/error_impl_error.rs b/clippy_lints/src/error_impl_error.rs
index 3018e1f12734..4b5a885c37f0 100644
--- a/clippy_lints/src/error_impl_error.rs
+++ b/clippy_lints/src/error_impl_error.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_hir_and_then};
-use clippy_utils::path_res;
+use clippy_utils::res::PathRes;
 use clippy_utils::ty::implements_trait;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{Item, ItemKind};
@@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
                 if let Some(trait_def_id) = imp.of_trait.and_then(|t| t.trait_ref.trait_def_id())
                     && let Some(error_def_id) = cx.tcx.get_diagnostic_item(sym::Error)
                     && error_def_id == trait_def_id
-                    && let Some(def_id) = path_res(cx, imp.self_ty).opt_def_id().and_then(DefId::as_local)
+                    && let Some(def_id) = cx.path_def_id(imp.self_ty).and_then(DefId::as_local)
                     && let Some(ident) = cx.tcx.opt_item_ident(def_id.to_def_id())
                     && ident.name == sym::Error
                     && is_visible_outside_module(cx, def_id) =>
diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs
index 085ee4448a4e..de8fbec7a6dc 100644
--- a/clippy_lints/src/explicit_write.rs
+++ b/clippy_lints/src/explicit_write.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::{FormatArgsStorage, format_args_inputs_span};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_expn_of, path_def_id, sym};
+use clippy_utils::{is_expn_of, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{BindingMode, Block, BlockCheckMode, Expr, ExprKind, Node, PatKind, QPath, Stmt, StmtKind};
@@ -59,12 +60,12 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
             && let ExprKind::MethodCall(write_fun, write_recv, [write_arg], _) = *look_in_block(cx, &write_call.kind)
             && let ExprKind::Call(write_recv_path, []) = write_recv.kind
             && write_fun.ident.name == sym::write_fmt
-            && let Some(def_id) = path_def_id(cx, write_recv_path)
+            && let Some(diag_name) = cx.path_diag_name(write_recv_path)
         {
             // match calls to std::io::stdout() / std::io::stderr ()
-            let (dest_name, prefix) = match cx.tcx.get_diagnostic_name(def_id) {
-                Some(sym::io_stdout) => ("stdout", ""),
-                Some(sym::io_stderr) => ("stderr", "e"),
+            let (dest_name, prefix) = match diag_name {
+                sym::io_stdout => ("stdout", ""),
+                sym::io_stderr => ("stderr", "e"),
                 _ => return,
             };
             let Some(format_args) = self.format_args.get(cx, write_arg, ExpnId::root()) else {
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index e3bb5ee10db7..e521331e3693 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -4,7 +4,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::span_is_local;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::path_def_id;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{Visitor, walk_path};
@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
                 |diag| {
                     // If the target type is likely foreign mention the orphan rules as it's a common source of
                     // confusion
-                    if path_def_id(cx, target_ty.peel_refs()).is_none_or(|id| !id.is_local()) {
+                    if cx.path_def_id(target_ty.peel_refs()).is_none_or(|id| !id.is_local()) {
                         diag.help(
                             "`impl From<Local> for Foreign` is allowed by the orphan rules, for more information see\n\
                             https://doc.rust-lang.org/reference/items/implementations.html#trait-implementation-coherence"
diff --git a/clippy_lints/src/from_raw_with_void_ptr.rs b/clippy_lints/src/from_raw_with_void_ptr.rs
index 5e2e2c9dbf72..f50afe516c35 100644
--- a/clippy_lints/src/from_raw_with_void_ptr.rs
+++ b/clippy_lints/src/from_raw_with_void_ptr.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::res::PathRes;
+use clippy_utils::sym;
 use clippy_utils::ty::is_c_void;
-use clippy_utils::{path_def_id, sym};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
@@ -41,7 +42,7 @@ impl LateLintPass<'_> for FromRawWithVoidPtr {
         if let ExprKind::Call(box_from_raw, [arg]) = expr.kind
             && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_from_raw.kind
             && seg.ident.name == sym::from_raw
-            && let Some(type_str) = path_def_id(cx, ty).and_then(|id| def_id_matches_type(cx, id))
+            && let Some(type_str) = cx.path_def_id(ty).and_then(|id| def_id_matches_type(cx, id))
             && let arg_kind = cx.typeck_results().expr_ty(arg).kind()
             && let ty::RawPtr(ty, _) = arg_kind
             && is_c_void(cx, *ty)
@@ -62,22 +63,14 @@ impl LateLintPass<'_> for FromRawWithVoidPtr {
 /// Checks whether a `DefId` matches `Box`, `Rc`, `Arc`, or one of the `Weak` types.
 /// Returns a static string slice with the name of the type, if one was found.
 fn def_id_matches_type(cx: &LateContext<'_>, def_id: DefId) -> Option<&'static str> {
-    // Box
     if Some(def_id) == cx.tcx.lang_items().owned_box() {
         return Some("Box");
     }
 
-    if let Some(symbol) = cx.tcx.get_diagnostic_name(def_id) {
-        if symbol == sym::Arc {
-            return Some("Arc");
-        } else if symbol == sym::Rc {
-            return Some("Rc");
-        }
-    }
-
-    if matches!(cx.tcx.get_diagnostic_name(def_id), Some(sym::RcWeak | sym::ArcWeak)) {
-        Some("Weak")
-    } else {
-        None
+    match cx.tcx.get_diagnostic_name(def_id) {
+        Some(sym::Arc) => Some("Arc"),
+        Some(sym::Rc) => Some("Rc"),
+        Some(sym::RcWeak | sym::ArcWeak) => Some("Weak"),
+        _ => None,
     }
 }
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index b50d91f10146..cf1d83c174a9 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -2,11 +2,11 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    contains_return, expr_adjustment_requires_coercion, higher, is_else_clause, is_in_const_context, is_res_lang_ctor,
-    path_res, peel_blocks, sym,
+    contains_return, expr_adjustment_requires_coercion, higher, is_else_clause, is_in_const_context, peel_blocks, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -73,8 +73,8 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && let ExprKind::Call(then_call, [then_arg]) = then_expr.kind
             && !expr.span.from_expansion()
             && !then_expr.span.from_expansion()
-            && is_res_lang_ctor(cx, path_res(cx, then_call), OptionSome)
-            && is_res_lang_ctor(cx, path_res(cx, peel_blocks(els)), OptionNone)
+            && cx.is_path_lang_ctor(then_call, OptionSome)
+            && cx.is_path_lang_ctor(peel_blocks(els), OptionNone)
             && !is_else_clause(cx.tcx, expr)
             && !is_in_const_context(cx)
             && self.msrv.meets(cx, msrvs::BOOL_THEN)
diff --git a/clippy_lints/src/instant_subtraction.rs b/clippy_lints/src/instant_subtraction.rs
index 13117f60abd5..0343c42c07d8 100644
--- a/clippy_lints/src/instant_subtraction.rs
+++ b/clippy_lints/src/instant_subtraction.rs
@@ -1,9 +1,10 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{is_path_diagnostic_item, ty};
+use clippy_utils::ty;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -107,7 +108,7 @@ impl LateLintPass<'_> for InstantSubtraction {
 
 fn is_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
     if let ExprKind::Call(fn_expr, []) = expr_block.kind
-        && is_path_diagnostic_item(cx, fn_expr, sym::instant_now)
+        && cx.is_path_diag_item(fn_expr, sym::instant_now)
     {
         true
     } else {
diff --git a/clippy_lints/src/loops/manual_find.rs b/clippy_lints/src/loops/manual_find.rs
index f99989ec6ba4..83decc5e5ba1 100644
--- a/clippy_lints/src/loops/manual_find.rs
+++ b/clippy_lints/src/loops/manual_find.rs
@@ -1,12 +1,12 @@
 use super::MANUAL_FIND;
 use super::utils::make_iterator_snippet;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::usage::contains_return_break_continue_macro;
-use clippy_utils::{higher, is_res_lang_ctor, path_res, peel_blocks_with_stmt};
+use clippy_utils::{higher, path_to_local_id, peel_blocks_with_stmt};
 use rustc_errors::Applicability;
-use rustc_hir::def::Res;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{BindingMode, Block, Expr, ExprKind, HirId, Node, Pat, PatKind, Stmt, StmtKind};
 use rustc_lint::LateContext;
@@ -34,8 +34,8 @@ pub(super) fn check<'tcx>(
         && let StmtKind::Semi(semi) = stmt.kind
         && let ExprKind::Ret(Some(ret_value)) = semi.kind
         && let ExprKind::Call(ctor, [inner_ret]) = ret_value.kind
-        && is_res_lang_ctor(cx, path_res(cx, ctor), LangItem::OptionSome)
-        && path_res(cx, inner_ret) == Res::Local(binding_id)
+        && cx.is_path_lang_ctor(ctor, LangItem::OptionSome)
+        && path_to_local_id(inner_ret, binding_id)
         && !contains_return_break_continue_macro(cond)
         && let Some((last_stmt, last_ret)) = last_stmt_and_ret(cx, expr)
     {
@@ -150,7 +150,7 @@ fn last_stmt_and_ret<'tcx>(
         && let Some((_, Node::Block(block))) = parent_iter.next()
         && let Some((last_stmt, last_ret)) = extract(block)
         && last_stmt.hir_id == node_hir
-        && is_res_lang_ctor(cx, path_res(cx, last_ret), LangItem::OptionNone)
+        && cx.is_path_lang_ctor(last_ret, LangItem::OptionNone)
         && let Some((_, Node::Expr(_block))) = parent_iter.next()
         // This includes the function header
         && let Some((_, func)) = parent_iter.next()
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 6000ff7a3609..4fb5ee5559e0 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -2,9 +2,10 @@ use std::ops::ControlFlow;
 
 use super::WHILE_LET_ON_ITERATOR;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::visitors::is_res_used;
-use clippy_utils::{get_enclosing_loop_or_multi_call_closure, higher, is_refutable, is_res_lang_ctor, is_trait_method};
+use clippy_utils::{get_enclosing_loop_or_multi_call_closure, higher, is_refutable, is_trait_method};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{Visitor, walk_expr};
@@ -19,7 +20,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if let Some(higher::WhileLet { if_then, let_pat, let_expr, label, .. }) = higher::WhileLet::hir(expr)
         // check for `Some(..)` pattern
         && let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind
-        && is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome)
+        && cx.is_path_lang_ctor((pat_path, let_pat.hir_id), LangItem::OptionSome)
         // check for call to `Iterator::next`
         && let ExprKind::MethodCall(method_name, iter_expr, [], _) = let_expr.kind
         && method_name.ident.name == sym::next
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index 42fe386d2c3c..1d2c3aa3c743 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -3,12 +3,13 @@ use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::higher::If;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::PathRes;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::is_const_evaluatable;
 use clippy_utils::{
-    MaybePath, eq_expr_value, is_diag_trait_item, is_in_const_context, is_trait_method, path_res, path_to_local_id,
-    peel_blocks, peel_blocks_with_stmt, sym,
+    eq_expr_value, is_diag_trait_item, is_in_const_context, is_trait_method, path_to_local_id, peel_blocks,
+    peel_blocks_with_stmt, sym,
 };
 use itertools::Itertools;
 use rustc_errors::{Applicability, Diag};
@@ -342,7 +343,7 @@ fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
                 }
             },
             ExprKind::Path(QPath::TypeRelative(ty, seg)) => {
-                matches!(path_res(cx, ty), Res::PrimTy(PrimTy::Float(_))).then(|| FunctionType::OrdOrFloat(seg))
+                matches!(cx.path_res(ty), Res::PrimTy(PrimTy::Float(_))).then(|| FunctionType::OrdOrFloat(seg))
             },
             _ => None,
         }
@@ -516,7 +517,7 @@ fn is_two_if_pattern<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) ->
                     },
                     span: first_expr.span.to(second_expr.span),
                     make_assignment: Some(maybe_input_first_path),
-                    hir_with_ignore_attr: Some(first_expr.hir_id()),
+                    hir_with_ignore_attr: Some(first_expr.hir_id),
                 })
             } else {
                 None
diff --git a/clippy_lints/src/manual_let_else.rs b/clippy_lints/src/manual_let_else.rs
index 5a7967bbf946..cd74bdaa1f42 100644
--- a/clippy_lints/src/manual_let_else.rs
+++ b/clippy_lints/src/manual_let_else.rs
@@ -2,16 +2,15 @@ use crate::question_mark::{QUESTION_MARK, QuestionMark};
 use clippy_config::types::MatchLintBehaviour;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLetOrMatch;
+use clippy_utils::macros::HirNode;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{
-    MaybePath, is_lint_allowed, is_never_expr, is_wild, msrvs, pat_and_expr_can_be_question_mark, path_res, peel_blocks,
-};
+use clippy_utils::{is_lint_allowed, is_never_expr, is_wild, msrvs, pat_and_expr_can_be_question_mark, peel_blocks};
 use rustc_ast::BindingMode;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorOf, DefKind, Res};
-use rustc_hir::{Arm, Expr, ExprKind, HirId, MatchSource, Pat, PatExpr, PatExprKind, PatKind, QPath, Stmt, StmtKind};
+use rustc_hir::{Arm, Expr, ExprKind, MatchSource, Pat, PatExpr, PatExprKind, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LintContext};
 use rustc_span::Span;
 use rustc_span::symbol::{Symbol, sym};
@@ -131,41 +130,27 @@ fn is_arms_disjointed(cx: &LateContext<'_>, arm1: &Arm<'_>, arm2: &Arm<'_>) -> b
 
 /// Returns `true` if the given pattern is a variant of an enum.
 pub fn is_enum_variant(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
-    struct Pat<'hir>(&'hir rustc_hir::Pat<'hir>);
-
-    impl<'hir> MaybePath<'hir> for Pat<'hir> {
-        fn qpath_opt(&self) -> Option<&QPath<'hir>> {
-            match self.0.kind {
-                PatKind::Struct(ref qpath, fields, _)
-                    if fields
-                        .iter()
-                        .all(|field| is_wild(field.pat) || matches!(field.pat.kind, PatKind::Binding(..))) =>
-                {
-                    Some(qpath)
-                },
-                PatKind::TupleStruct(ref qpath, pats, _)
-                    if pats
-                        .iter()
-                        .all(|pat| is_wild(pat) || matches!(pat.kind, PatKind::Binding(..))) =>
-                {
-                    Some(qpath)
-                },
-                PatKind::Expr(&PatExpr {
-                    kind: PatExprKind::Path(ref qpath),
-                    ..
-                }) => Some(qpath),
-                _ => None,
-            }
-        }
-
-        fn hir_id(&self) -> HirId {
-            self.0.hir_id
-        }
-    }
+    let (qpath, hir_id) = match pat.kind {
+        PatKind::Struct(ref qpath, fields, _)
+            if fields
+                .iter()
+                .all(|field| is_wild(field.pat) || matches!(field.pat.kind, PatKind::Binding(..))) =>
+        {
+            (qpath, pat.hir_id())
+        },
+        PatKind::TupleStruct(ref qpath, pats, _)
+            if pats
+                .iter()
+                .all(|pat| is_wild(pat) || matches!(pat.kind, PatKind::Binding(..))) =>
+        {
+            (qpath, pat.hir_id)
+        },
+        PatKind::Expr(e) if let PatExprKind::Path(qpath) = &e.kind => (qpath, e.hir_id),
+        _ => return false,
+    };
 
-    let res = path_res(cx, &Pat(pat));
     matches!(
-        res,
+        cx.qpath_res(qpath, hir_id),
         Res::Def(DefKind::Variant, ..) | Res::Def(DefKind::Ctor(CtorOf::Variant, _), _)
     )
 }
diff --git a/clippy_lints/src/manual_option_as_slice.rs b/clippy_lints/src/manual_option_as_slice.rs
index 922db174e3d4..7a6976f02b08 100644
--- a/clippy_lints/src/manual_option_as_slice.rs
+++ b/clippy_lints/src/manual_option_as_slice.rs
@@ -1,6 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::msrvs::Msrv;
+use clippy_utils::res::PathRes;
 use clippy_utils::{is_none_arm, msrvs, peel_hir_expr_refs, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -95,12 +96,12 @@ impl LateLintPass<'_> for ManualOptionAsSlice {
             },
             ExprKind::MethodCall(seg, callee, [or_else, map], _) => match seg.ident.name {
                 sym::map_or => {
-                    if is_empty_slice(cx, or_else) && is_slice_from_ref(cx, map) {
+                    if is_empty_slice(cx, or_else) && cx.is_path_diag_item(map, sym::slice_from_ref) {
                         check_as_ref(cx, callee, span, self.msrv);
                     }
                 },
                 sym::map_or_else => {
-                    if returns_empty_slice(cx, or_else) && is_slice_from_ref(cx, map) {
+                    if returns_empty_slice(cx, or_else) && cx.is_path_diag_item(map, sym::slice_from_ref) {
                         check_as_ref(cx, callee, span, self.msrv);
                     }
                 },
@@ -114,7 +115,7 @@ impl LateLintPass<'_> for ManualOptionAsSlice {
 fn check_map(cx: &LateContext<'_>, map: &Expr<'_>, span: Span, msrv: Msrv) {
     if let ExprKind::MethodCall(seg, callee, [mapping], _) = map.kind
         && seg.ident.name == sym::map
-        && is_slice_from_ref(cx, mapping)
+        && cx.is_path_diag_item(mapping, sym::slice_from_ref)
     {
         check_as_ref(cx, callee, span, msrv);
     }
@@ -165,7 +166,7 @@ fn extract_ident_from_some_pat(cx: &LateContext<'_>, pat: &Pat<'_>) -> Option<Sy
 /// Returns true if `expr` is `std::slice::from_ref(<name>)`. Used in `if let`s.
 fn check_some_body(cx: &LateContext<'_>, name: Symbol, expr: &Expr<'_>) -> bool {
     if let ExprKind::Call(slice_from_ref, [arg]) = expr.peel_blocks().kind
-        && is_slice_from_ref(cx, slice_from_ref)
+        && cx.is_path_diag_item(slice_from_ref, sym::slice_from_ref)
         && let ExprKind::Path(QPath::Resolved(None, path)) = arg.kind
         && let [seg] = path.segments
     {
@@ -189,7 +190,7 @@ fn check_arms(cx: &LateContext<'_>, none_arm: &Arm<'_>, some_arm: &Arm<'_>) -> b
 
 fn returns_empty_slice(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match expr.kind {
-        ExprKind::Path(_) => clippy_utils::is_path_diagnostic_item(cx, expr, sym::default_fn),
+        ExprKind::Path(_) => cx.is_path_diag_item(expr, sym::default_fn),
         ExprKind::Closure(cl) => is_empty_slice(cx, cx.tcx.hir_body(cl.body).value),
         _ => false,
     }
@@ -214,11 +215,7 @@ fn is_empty_slice(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
             _ => false,
         },
         ExprKind::Array([]) => true,
-        ExprKind::Call(def, []) => clippy_utils::is_path_diagnostic_item(cx, def, sym::default_fn),
+        ExprKind::Call(def, []) => cx.is_path_diag_item(def, sym::default_fn),
         _ => false,
     }
 }
-
-fn is_slice_from_ref(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    clippy_utils::is_path_diagnostic_item(cx, expr, sym::slice_from_ref)
-}
diff --git a/clippy_lints/src/match_result_ok.rs b/clippy_lints/src/match_result_ok.rs
index e0cb5d14d3c9..9f190456fbe2 100644
--- a/clippy_lints/src/match_result_ok.rs
+++ b/clippy_lints/src/match_result_ok.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{higher, is_res_lang_ctor, sym};
+use clippy_utils::{higher, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, LangItem, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -58,7 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchResultOk {
             && let PatKind::TupleStruct(ref pat_path, [ok_pat], _)  = let_pat.kind //get operation
             && ok_path.ident.name == sym::ok
             && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
-            && is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome)
+            && cx.is_path_lang_ctor((pat_path, let_pat.hir_id), LangItem::OptionSome)
             && let ctxt = expr.span.ctxt()
             && let_expr.span.ctxt() == ctxt
             && let_pat.span.ctxt() == ctxt
diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index aaf559fc4439..83f845a4a4e1 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -1,16 +1,16 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::msrvs::Msrv;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{
-    SpanlessEq, get_ref_operators, is_res_lang_ctor, is_unit_expr, path_to_local, peel_blocks_with_stmt,
-    peel_ref_operators,
+    SpanlessEq, get_ref_operators, is_unit_expr, path_to_local, peel_blocks_with_stmt, peel_ref_operators,
 };
 use rustc_ast::BorrowKind;
 use rustc_errors::MultiSpan;
 use rustc_hir::LangItem::OptionNone;
-use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatExpr, PatExprKind, PatKind};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
@@ -131,11 +131,7 @@ fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     }
     match arm.pat.kind {
         PatKind::Binding(..) | PatKind::Wild => true,
-        PatKind::Expr(PatExpr {
-            kind: PatExprKind::Path(qpath),
-            hir_id,
-            ..
-        }) => is_res_lang_ctor(cx, cx.qpath_res(qpath, *hir_id), OptionNone),
+        PatKind::Expr(e) => cx.is_path_lang_ctor(e, OptionNone),
         _ => false,
     }
 }
diff --git a/clippy_lints/src/matches/manual_filter.rs b/clippy_lints/src/matches/manual_filter.rs
index abf723fa6f4c..e9f9be963438 100644
--- a/clippy_lints/src/matches/manual_filter.rs
+++ b/clippy_lints/src/matches/manual_filter.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::path_to_local_id;
+use clippy_utils::res::PathRes;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::contains_unsafe_block;
-use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
 
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatKind};
@@ -65,16 +66,14 @@ fn is_some_expr(cx: &LateContext<'_>, target: HirId, ctxt: SyntaxContext, expr:
         // there can be not statements in the block as they would be removed when switching to `.filter`
         && let ExprKind::Call(callee, [arg]) = inner_expr.kind
     {
-        return ctxt == expr.span.ctxt()
-            && is_res_lang_ctor(cx, path_res(cx, callee), OptionSome)
-            && path_to_local_id(arg, target);
+        return ctxt == expr.span.ctxt() && cx.is_path_lang_ctor(callee, OptionSome) && path_to_local_id(arg, target);
     }
     false
 }
 
 fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if let Some(inner_expr) = peels_blocks_incl_unsafe_opt(expr) {
-        return is_res_lang_ctor(cx, path_res(cx, inner_expr), OptionNone);
+        return cx.is_path_lang_ctor(inner_expr, OptionNone);
     }
     false
 }
diff --git a/clippy_lints/src/matches/manual_map.rs b/clippy_lints/src/matches/manual_map.rs
index de57d1eee924..0c744a490b61 100644
--- a/clippy_lints/src/matches/manual_map.rs
+++ b/clippy_lints/src/matches/manual_map.rs
@@ -1,8 +1,7 @@
 use super::MANUAL_MAP;
 use super::manual_utils::{SomeExpr, check_with};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-
-use clippy_utils::{is_res_lang_ctor, path_res};
+use clippy_utils::res::PathRes;
 
 use rustc_hir::LangItem::OptionSome;
 use rustc_hir::{Arm, Block, BlockCheckMode, Expr, ExprKind, Pat, UnsafeSource};
@@ -90,9 +89,7 @@ fn get_some_expr<'tcx>(
     ) -> Option<SomeExpr<'tcx>> {
         // TODO: Allow more complex expressions.
         match expr.kind {
-            ExprKind::Call(callee, [arg])
-                if ctxt == expr.span.ctxt() && is_res_lang_ctor(cx, path_res(cx, callee), OptionSome) =>
-            {
+            ExprKind::Call(callee, [arg]) if ctxt == expr.span.ctxt() && cx.is_path_lang_ctor(callee, OptionSome) => {
                 Some(SomeExpr::new_no_negated(arg, needs_unsafe_block))
             },
             ExprKind::Block(
diff --git a/clippy_lints/src/matches/manual_ok_err.rs b/clippy_lints/src/matches/manual_ok_err.rs
index edbb556fd976..bf6e8f978f48 100644
--- a/clippy_lints/src/matches/manual_ok_err.rs
+++ b/clippy_lints/src/matches/manual_ok_err.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{indent_of, reindent_multiline};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{option_arg_ty, peel_mid_ty_refs_is_mutable};
-use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res, peel_blocks, span_contains_comment};
+use clippy_utils::{get_parent_expr, peel_blocks, span_contains_comment};
 use rustc_ast::{BindingMode, Mutability};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr};
@@ -71,9 +72,7 @@ fn is_variant_or_wildcard(cx: &LateContext<'_>, pat: &Pat<'_>, can_be_wild: bool
         {
             true
         },
-        PatKind::TupleStruct(qpath, ..) => {
-            is_res_lang_ctor(cx, cx.qpath_res(&qpath, pat.hir_id), ResultErr) == must_match_err
-        },
+        PatKind::TupleStruct(ref qpath, ..) => cx.is_path_lang_ctor((qpath, pat.hir_id), ResultErr) == must_match_err,
         PatKind::Binding(_, _, _, Some(pat)) | PatKind::Ref(pat, _) => {
             is_variant_or_wildcard(cx, pat, can_be_wild, must_match_err)
         },
@@ -103,7 +102,7 @@ fn is_ok_or_err<'hir>(cx: &LateContext<'_>, pat: &Pat<'hir>) -> Option<(bool, &'
 /// Check if `expr` contains `Some(ident)`, possibly as a block
 fn is_some_ident<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, ident: &Ident, ty: Ty<'tcx>) -> bool {
     if let ExprKind::Call(body_callee, [body_arg]) = peel_blocks(expr).kind
-        && is_res_lang_ctor(cx, path_res(cx, body_callee), OptionSome)
+        && cx.is_path_lang_ctor(body_callee, OptionSome)
         && cx.typeck_results().expr_ty(body_arg) == ty
         && let ExprKind::Path(QPath::Resolved(
             _,
@@ -120,7 +119,7 @@ fn is_some_ident<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, ident: &Ident, t
 
 /// Check if `expr` is `None`, possibly as a block
 fn is_none(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    is_res_lang_ctor(cx, path_res(cx, peel_blocks(expr)), OptionNone)
+    cx.is_path_lang_ctor(peel_blocks(expr), OptionNone)
 }
 
 /// Suggest replacing `expr` by `scrutinee.METHOD()`, where `METHOD` is either `ok` or
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index 8c3f52542d91..cbd5f2483efc 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -9,9 +9,10 @@ use rustc_middle::ty::{GenericArgKind, Ty};
 use rustc_span::sym;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{expr_type_is_certain, get_type_diagnostic_name, implements_trait};
-use clippy_utils::{is_default_equivalent, is_lint_allowed, path_res, peel_blocks, span_contains_comment};
+use clippy_utils::{is_default_equivalent, is_lint_allowed, peel_blocks, span_contains_comment};
 
 use super::{MANUAL_UNWRAP_OR, MANUAL_UNWRAP_OR_DEFAULT};
 
@@ -114,10 +115,7 @@ fn handle(
             && is_default_equivalent(cx, peel_blocks(body_none))
         {
             // We now check if the condition is a None variant, in which case we need to specify the type
-            if path_res(cx, condition)
-                .opt_def_id()
-                .is_some_and(|id| Some(cx.tcx.parent(id)) == cx.tcx.lang_items().option_none_variant())
-            {
+            if cx.is_path_lang_ctor(condition, LangItem::OptionNone) {
                 return span_lint_and_sugg(
                     cx,
                     MANUAL_UNWRAP_OR_DEFAULT,
diff --git a/clippy_lints/src/matches/manual_utils.rs b/clippy_lints/src/matches/manual_utils.rs
index dbae71bbb1b0..6fe26d8a1a8c 100644
--- a/clippy_lints/src/matches/manual_utils.rs
+++ b/clippy_lints/src/matches/manual_utils.rs
@@ -1,17 +1,18 @@
 use crate::map_unit_fn::OPTION_MAP_UNIT_FN;
 use crate::matches::MATCH_AS_REF;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
 use clippy_utils::{
-    CaptureKind, can_move_expr_to_closure, expr_requires_coercion, is_else_clause, is_lint_allowed, is_res_lang_ctor,
-    path_res, path_to_local_id, peel_blocks, peel_hir_expr_refs, peel_hir_expr_while,
+    CaptureKind, can_move_expr_to_closure, expr_requires_coercion, is_else_clause, is_lint_allowed, path_to_local_id,
+    peel_blocks, peel_hir_expr_refs, peel_hir_expr_while,
 };
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::def::Res;
-use rustc_hir::{BindingMode, Expr, ExprKind, HirId, Mutability, Pat, PatExpr, PatExprKind, PatKind, Path, QPath};
+use rustc_hir::{BindingMode, Expr, ExprKind, HirId, Mutability, Pat, PatKind, Path, QPath};
 use rustc_lint::LateContext;
 use rustc_span::{SyntaxContext, sym};
 
@@ -254,13 +255,9 @@ pub(super) fn try_parse_pattern<'tcx>(
         match pat.kind {
             PatKind::Wild => Some(OptionPat::Wild),
             PatKind::Ref(pat, _) => f(cx, pat, ref_count + 1, ctxt),
-            PatKind::Expr(PatExpr {
-                kind: PatExprKind::Path(qpath),
-                hir_id,
-                ..
-            }) if is_res_lang_ctor(cx, cx.qpath_res(qpath, *hir_id), OptionNone) => Some(OptionPat::None),
+            PatKind::Expr(e) if cx.is_path_lang_ctor(e, OptionNone) => Some(OptionPat::None),
             PatKind::TupleStruct(ref qpath, [pattern], _)
-                if is_res_lang_ctor(cx, cx.qpath_res(qpath, pat.hir_id), OptionSome) && pat.span.ctxt() == ctxt =>
+                if cx.is_path_lang_ctor((qpath, pat.hir_id), OptionSome) && pat.span.ctxt() == ctxt =>
             {
                 Some(OptionPat::Some { pattern, ref_count })
             },
@@ -272,5 +269,5 @@ pub(super) fn try_parse_pattern<'tcx>(
 
 // Checks for the `None` value.
 fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    is_res_lang_ctor(cx, path_res(cx, peel_blocks(expr)), OptionNone)
+    cx.is_path_lang_ctor(peel_blocks(expr), OptionNone)
 }
diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
index 1cb4b512a30e..97301ebcd112 100644
--- a/clippy_lints/src/matches/match_as_ref.rs
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_none_arm, is_res_lang_ctor, path_res, peel_blocks};
+use clippy_utils::{is_none_arm, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BindingMode, ByRef, Expr, ExprKind, LangItem, Mutability, PatKind, QPath};
 use rustc_lint::LateContext;
@@ -58,10 +59,10 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
 // Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
 fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<Mutability> {
     if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind
-        && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), LangItem::OptionSome)
+        && cx.is_path_lang_ctor((qpath, arm.pat.hir_id), LangItem::OptionSome)
         && let PatKind::Binding(BindingMode(ByRef::Yes(mutabl), _), .., ident, _) = first_pat.kind
         && let ExprKind::Call(e, [arg]) = peel_blocks(arm.body).kind
-        && is_res_lang_ctor(cx, path_res(cx, e), LangItem::OptionSome)
+        && cx.is_path_lang_ctor(e, LangItem::OptionSome)
         && let ExprKind::Path(QPath::Resolved(_, path2)) = arg.kind
         && path2.segments.len() == 1
         && ident.name == path2.segments[0].ident.name
diff --git a/clippy_lints/src/matches/needless_match.rs b/clippy_lints/src/matches/needless_match.rs
index b04db03f8d2e..ba1423256728 100644
--- a/clippy_lints/src/matches/needless_match.rs
+++ b/clippy_lints/src/matches/needless_match.rs
@@ -1,10 +1,10 @@
 use super::NEEDLESS_MATCH;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
 use clippy_utils::{
-    SpanlessEq, eq_expr_value, get_parent_expr_for_hir, higher, is_else_clause, is_res_lang_ctor, over, path_res,
-    peel_blocks_with_stmt,
+    SpanlessEq, eq_expr_value, get_parent_expr_for_hir, higher, is_else_clause, over, peel_blocks_with_stmt,
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
@@ -105,8 +105,7 @@ fn check_if_let_inner(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) -> bool
             }
             let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr);
             if is_type_diagnostic_item(cx, let_expr_ty, sym::Option) {
-                return is_res_lang_ctor(cx, path_res(cx, else_expr), OptionNone)
-                    || eq_expr_value(cx, if_let.let_expr, else_expr);
+                return cx.is_path_lang_ctor(else_expr, OptionNone) || eq_expr_value(cx, if_let.let_expr, else_expr);
             }
             return eq_expr_value(cx, if_let.let_expr, else_expr);
         }
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index af90cb5e6733..be7e13841507 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::get_parent_expr;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::option_arg_ty;
-use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::ResultErr;
 use rustc_hir::{Expr, ExprKind, LangItem, MatchSource, QPath};
@@ -25,7 +26,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
         && let ExprKind::Path(ref match_fun_path) = match_fun.kind
         && matches!(match_fun_path, QPath::LangItem(LangItem::TryTraitBranch, ..))
         && let ExprKind::Call(err_fun, [err_arg]) = try_arg.kind
-        && is_res_lang_ctor(cx, path_res(cx, err_fun), ResultErr)
+        && cx.is_path_lang_ctor(err_fun, ResultErr)
         && let Some(return_ty) = find_return_type(cx, &expr.kind)
     {
         let (prefix, suffix, err_ty) = if let Some(ty) = result_error_type(cx, return_ty) {
diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs
index e39916f733d5..65e40d669d16 100644
--- a/clippy_lints/src/mem_replace.rs
+++ b/clippy_lints/src/mem_replace.rs
@@ -1,12 +1,11 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{
-    is_default_equivalent, is_expr_used_or_unified, is_res_lang_ctor, path_res, peel_ref_operators, std_or_core,
-};
+use clippy_utils::{is_default_equivalent, is_expr_used_or_unified, peel_ref_operators, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
@@ -129,7 +128,7 @@ impl_lint_pass!(MemReplace =>
     [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_OPTION_WITH_SOME, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
 
 fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) -> bool {
-    if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
+    if cx.is_path_lang_ctor(src, OptionNone) {
         // Since this is a late pass (already type-checked),
         // and we already know that the second argument is an
         // `Option`, we do not need to check the first
@@ -163,7 +162,7 @@ fn check_replace_option_with_some(
     msrv: Msrv,
 ) -> bool {
     if let ExprKind::Call(src_func, [src_arg]) = src.kind
-        && is_res_lang_ctor(cx, path_res(cx, src_func), OptionSome)
+        && cx.is_path_lang_ctor(src_func, OptionSome)
         && msrv.meets(cx, msrvs::OPTION_REPLACE)
     {
         // We do not have to check for a `const` context here, because `core::mem::replace()` and
diff --git a/clippy_lints/src/methods/chars_cmp.rs b/clippy_lints/src/methods/chars_cmp.rs
index de27a45ba4d9..c10ffb17c476 100644
--- a/clippy_lints/src/methods/chars_cmp.rs
+++ b/clippy_lints/src/methods/chars_cmp.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::method_chain_args;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{method_chain_args, path_def_id};
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::{self as hir, LangItem};
 use rustc_lint::{LateContext, Lint};
 use rustc_middle::ty;
 use rustc_span::Symbol;
@@ -17,8 +18,7 @@ pub(super) fn check(
 ) -> bool {
     if let Some(args) = method_chain_args(info.chain, chain_methods)
         && let hir::ExprKind::Call(fun, [arg_char]) = info.other.kind
-        && let Some(id) = path_def_id(cx, fun).map(|ctor_id| cx.tcx.parent(ctor_id))
-        && Some(id) == cx.tcx.lang_items().option_some_variant()
+        && cx.is_path_lang_ctor(fun, LangItem::OptionSome)
     {
         let mut applicability = Applicability::MachineApplicable;
         let self_ty = cx.typeck_results().expr_ty_adjusted(args[0].0).peel_refs();
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index d664eaaac704..59b206fac02a 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -1,9 +1,10 @@
 use std::fmt::Write as _;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{is_path_diagnostic_item, sugg};
 use rustc_ast::join_path_idents;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -15,7 +16,7 @@ use rustc_span::sym;
 use super::FROM_ITER_INSTEAD_OF_COLLECT;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<'_>], func: &Expr<'_>) {
-    if is_path_diagnostic_item(cx, func, sym::from_iter_fn)
+    if cx.is_path_diag_item(func, sym::from_iter_fn)
         && let arg_ty = cx.typeck_results().expr_ty(&args[0])
         && let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
         && implements_trait(cx, arg_ty, iter_id, &[])
diff --git a/clippy_lints/src/methods/io_other_error.rs b/clippy_lints/src/methods/io_other_error.rs
index 9276261606e1..c5a2f7c9a346 100644
--- a/clippy_lints/src/methods/io_other_error.rs
+++ b/clippy_lints/src/methods/io_other_error.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::{expr_or_init, is_path_diagnostic_item, sym};
+use clippy_utils::res::PathRes;
+use clippy_utils::{expr_or_init, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
@@ -10,7 +11,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, path: &Expr<'_>, args
         && !expr.span.from_expansion()
         && !error_kind.span.from_expansion()
         && let ExprKind::Path(QPath::TypeRelative(_, new_segment)) = path.kind
-        && is_path_diagnostic_item(cx, path, sym::io_error_new)
+        && cx.is_path_diag_item(path, sym::io_error_new)
         && let ExprKind::Path(QPath::Resolved(_, init_path)) = &expr_or_init(cx, error_kind).kind
         && let [.., error_kind_ty, error_kind_variant] = init_path.segments
         && cx.tcx.is_diagnostic_item(sym::io_errorkind, error_kind_ty.res.def_id())
diff --git a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
index 83e565562af0..371e8257c7f9 100644
--- a/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
+++ b/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs
@@ -1,9 +1,10 @@
 use std::iter::once;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{ExprFnSig, expr_sig, ty_sig};
-use clippy_utils::{get_expr_use_or_unification_node, is_res_lang_ctor, path_res, std_or_core, sym};
+use clippy_utils::{get_expr_use_or_unification_node, std_or_core, sym};
 
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -67,8 +68,8 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method
     let item = match recv.kind {
         ExprKind::Array([]) => None,
         ExprKind::Array([e]) => Some(e),
-        ExprKind::Path(ref p) if is_res_lang_ctor(cx, cx.qpath_res(p, recv.hir_id), OptionNone) => None,
-        ExprKind::Call(f, [arg]) if is_res_lang_ctor(cx, path_res(cx, f), OptionSome) => Some(arg),
+        ExprKind::Path(ref p) if cx.is_path_lang_ctor((p, recv.hir_id), OptionNone) => None,
+        ExprKind::Call(f, [arg]) if cx.is_path_lang_ctor(f, OptionSome) => Some(arg),
         _ => return,
     };
     let iter_type = match method_name {
diff --git a/clippy_lints/src/methods/manual_ok_or.rs b/clippy_lints/src/methods/manual_ok_or.rs
index 077957fa44dc..2ca3a2d99550 100644
--- a/clippy_lints/src/methods/manual_ok_or.rs
+++ b/clippy_lints/src/methods/manual_ok_or.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::path_to_local_id;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{SpanRangeExt, indent_of, reindent_multiline};
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{ResultErr, ResultOk};
 use rustc_hir::{Expr, ExprKind, PatKind};
@@ -21,7 +22,7 @@ pub(super) fn check<'tcx>(
         && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id)
         && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Option)
         && let ExprKind::Call(err_path, [err_arg]) = or_expr.kind
-        && is_res_lang_ctor(cx, path_res(cx, err_path), ResultErr)
+        && cx.is_path_lang_ctor(err_path, ResultErr)
         && is_ok_wrapping(cx, map_expr)
         && let Some(recv_snippet) = recv.span.get_source_text(cx)
         && let Some(err_arg_snippet) = err_arg.span.get_source_text(cx)
@@ -42,12 +43,12 @@ pub(super) fn check<'tcx>(
 
 fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
     match map_expr.kind {
-        ExprKind::Path(ref qpath) if is_res_lang_ctor(cx, cx.qpath_res(qpath, map_expr.hir_id), ResultOk) => true,
+        ExprKind::Path(ref qpath) if cx.is_path_lang_ctor((qpath, map_expr.hir_id), ResultOk) => true,
         ExprKind::Closure(closure) => {
             let body = cx.tcx.hir_body(closure.body);
             if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind
                 && let ExprKind::Call(callee, [ok_arg]) = body.value.kind
-                && is_res_lang_ctor(cx, path_res(cx, callee), ResultOk)
+                && cx.is_path_lang_ctor(callee, ResultOk)
             {
                 path_to_local_id(ok_arg, param_id)
             } else {
diff --git a/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
index c785b23bc9c4..acc6bf4f2597 100644
--- a/clippy_lints/src/methods/manual_saturating_arithmetic.rs
+++ b/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{path_res, sym};
+use clippy_utils::sym;
 use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -83,7 +84,7 @@ fn is_min_or_max(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<MinMax> {
 
     // `T::MAX` and `T::MIN` constants
     if let hir::ExprKind::Path(hir::QPath::TypeRelative(base, seg)) = expr.kind
-        && let Res::PrimTy(_) = path_res(cx, base)
+        && let Res::PrimTy(_) = cx.path_res(base)
     {
         match seg.ident.name {
             sym::MAX => return Some(MinMax::Max),
diff --git a/clippy_lints/src/methods/manual_str_repeat.rs b/clippy_lints/src/methods/manual_str_repeat.rs
index a811dd1cee18..b6193aa01d1e 100644
--- a/clippy_lints/src/methods/manual_str_repeat.rs
+++ b/clippy_lints/src/methods/manual_str_repeat.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_path_diagnostic_item;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
@@ -55,7 +55,7 @@ pub(super) fn check(
     take_arg: &Expr<'_>,
 ) {
     if let ExprKind::Call(repeat_fn, [repeat_arg]) = take_self_arg.kind
-        && is_path_diagnostic_item(cx, repeat_fn, sym::iter_repeat)
+        && cx.is_path_diag_item(repeat_fn, sym::iter_repeat)
         && is_type_lang_item(cx, cx.typeck_results().expr_ty(collect_expr), LangItem::String)
         && let Some(take_id) = cx.typeck_results().type_dependent_def_id(take_expr.hir_id)
         && let Some(iter_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
diff --git a/clippy_lints/src/methods/needless_character_iteration.rs b/clippy_lints/src/methods/needless_character_iteration.rs
index 71c1576cd57d..43a59203c556 100644
--- a/clippy_lints/src/methods/needless_character_iteration.rs
+++ b/clippy_lints/src/methods/needless_character_iteration.rs
@@ -7,8 +7,9 @@ use rustc_span::Span;
 use super::NEEDLESS_CHARACTER_ITERATION;
 use super::utils::get_last_chain_binding_hir_id;
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::SpanRangeExt;
-use clippy_utils::{is_path_diagnostic_item, path_to_local_id, peel_blocks, sym};
+use clippy_utils::{path_to_local_id, peel_blocks, sym};
 
 fn peels_expr_ref<'a, 'tcx>(mut expr: &'a Expr<'tcx>) -> &'a Expr<'tcx> {
     while let ExprKind::AddrOf(_, _, e) = expr.kind {
@@ -75,7 +76,7 @@ fn handle_expr(
             // If we have `!is_ascii`, then only `.any()` should warn. And if the condition is
             // `is_ascii`, then only `.all()` should warn.
             if revert != is_all
-                && is_path_diagnostic_item(cx, fn_path, sym::char_is_ascii)
+                && cx.is_path_diag_item(fn_path, sym::char_is_ascii)
                 && path_to_local_id(peels_expr_ref(arg), first_param)
                 && let Some(snippet) = before_chars.get_source_text(cx)
             {
diff --git a/clippy_lints/src/methods/needless_option_as_deref.rs b/clippy_lints/src/methods/needless_option_as_deref.rs
index d77d044340dc..9584fd979c79 100644
--- a/clippy_lints/src/methods/needless_option_as_deref.rs
+++ b/clippy_lints/src/methods/needless_option_as_deref.rs
@@ -2,10 +2,9 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::local_used_after_expr;
-use clippy_utils::{path_res, sym};
+use clippy_utils::{path_to_local, sym};
 use rustc_errors::Applicability;
 use rustc_hir::Expr;
-use rustc_hir::def::Res;
 use rustc_lint::LateContext;
 use rustc_span::Symbol;
 
@@ -17,7 +16,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, name
 
     if is_type_diagnostic_item(cx, outer_ty, sym::Option) && outer_ty == typeck.expr_ty(recv) {
         if name == sym::as_deref_mut && recv.is_syntactic_place_expr() {
-            let Res::Local(binding_id) = path_res(cx, recv) else {
+            let Some(binding_id) = path_to_local(recv) else {
                 return;
             };
 
diff --git a/clippy_lints/src/methods/option_map_or_none.rs b/clippy_lints/src/methods/option_map_or_none.rs
index 1a273f77fb7d..0552561e75d0 100644
--- a/clippy_lints/src/methods/option_map_or_none.rs
+++ b/clippy_lints/src/methods/option_map_or_none.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_res_lang_ctor, path_def_id, path_res};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -49,21 +49,18 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    if !is_res_lang_ctor(cx, path_res(cx, def_arg), OptionNone) {
+    if !cx.is_path_lang_ctor(def_arg, OptionNone) {
         // nothing to lint!
         return;
     }
 
-    let f_arg_is_some = is_res_lang_ctor(cx, path_res(cx, map_arg), OptionSome);
-
     if is_option {
         let self_snippet = snippet(cx, recv.span, "..");
         if let hir::ExprKind::Closure(&hir::Closure { body, fn_decl_span, .. }) = map_arg.kind
             && let arg_snippet = snippet(cx, fn_decl_span, "..")
             && let body = cx.tcx.hir_body(body)
             && let Some((func, [arg_char])) = reduce_unit_expression(body.value)
-            && let Some(id) = path_def_id(cx, func).map(|ctor_id| cx.tcx.parent(ctor_id))
-            && Some(id) == cx.tcx.lang_items().option_some_variant()
+            && cx.is_path_lang_ctor(func, OptionSome)
         {
             let func_snippet = snippet(cx, arg_char.span, "..");
             let msg = "called `map_or(None, ..)` on an `Option` value";
@@ -89,7 +86,7 @@ pub(super) fn check<'tcx>(
             format!("{self_snippet}.and_then({func_snippet})"),
             Applicability::MachineApplicable,
         );
-    } else if f_arg_is_some {
+    } else if cx.is_path_lang_ctor(map_arg, OptionSome) {
         let msg = "called `map_or(None, Some)` on a `Result` value";
         let self_snippet = snippet(cx, recv.span, "..");
         span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/or_then_unwrap.rs b/clippy_lints/src/methods/or_then_unwrap.rs
index 1a760ea733d7..974e7655711d 100644
--- a/clippy_lints/src/methods/or_then_unwrap.rs
+++ b/clippy_lints/src/methods/or_then_unwrap.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_res_lang_ctor, path_res};
 use rustc_errors::Applicability;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{Expr, ExprKind};
@@ -60,7 +60,7 @@ pub(super) fn check<'tcx>(
 
 fn get_content_if_ctor_matches(cx: &LateContext<'_>, expr: &Expr<'_>, item: LangItem) -> Option<Span> {
     if let ExprKind::Call(some_expr, [arg]) = expr.kind
-        && is_res_lang_ctor(cx, path_res(cx, some_expr), item)
+        && cx.is_path_lang_ctor(some_expr, item)
     {
         Some(arg.span.source_callsite())
     } else {
diff --git a/clippy_lints/src/methods/result_map_or_else_none.rs b/clippy_lints/src/methods/result_map_or_else_none.rs
index af619c9e3bb1..86b9d2fcc065 100644
--- a/clippy_lints/src/methods/result_map_or_else_none.rs
+++ b/clippy_lints/src/methods/result_map_or_else_none.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::peel_blocks;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_res_lang_ctor, path_res, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -21,11 +22,11 @@ pub(super) fn check<'tcx>(
     // lint if the caller of `map_or_else()` is a `Result`
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
         // We check that it is mapped as `Some`.
-        && is_res_lang_ctor(cx, path_res(cx, map_arg), OptionSome)
+        && cx.is_path_lang_ctor(map_arg, OptionSome)
         && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = def_arg.kind
         && let body = cx.tcx.hir_body(body)
         // And finally we check that we return a `None` in the "else case".
-        && is_res_lang_ctor(cx, path_res(cx, peel_blocks(body.value)), OptionNone)
+        && cx.is_path_lang_ctor(peel_blocks(body.value), OptionNone)
     {
         let msg = "called `map_or_else(|_| None, Some)` on a `Result` value";
         let self_snippet = snippet(cx, recv.span, "..");
diff --git a/clippy_lints/src/methods/uninit_assumed_init.rs b/clippy_lints/src/methods/uninit_assumed_init.rs
index 6371fe644282..58bc69abfdbe 100644
--- a/clippy_lints/src/methods/uninit_assumed_init.rs
+++ b/clippy_lints/src/methods/uninit_assumed_init.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_path_diagnostic_item;
+use clippy_utils::res::PathRes;
 use clippy_utils::ty::is_uninit_value_valid_for_ty;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -10,7 +10,7 @@ use super::UNINIT_ASSUMED_INIT;
 /// lint for `MaybeUninit::uninit().assume_init()` (we already have the latter)
 pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
     if let hir::ExprKind::Call(callee, []) = recv.kind
-        && is_path_diagnostic_item(cx, callee, sym::maybe_uninit_uninit)
+        && cx.is_path_diag_item(callee, sym::maybe_uninit_uninit)
         && !is_uninit_value_valid_for_ty(cx, cx.typeck_results().expr_ty_adjusted(expr))
     {
         span_lint(
diff --git a/clippy_lints/src/methods/unnecessary_filter_map.rs b/clippy_lints/src/methods/unnecessary_filter_map.rs
index d260e0ef6e19..f6c3dfe1b8fc 100644
--- a/clippy_lints/src/methods/unnecessary_filter_map.rs
+++ b/clippy_lints/src/methods/unnecessary_filter_map.rs
@@ -1,9 +1,10 @@
 use super::utils::clone_or_copy_needed;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::res::PathRes;
 use clippy_utils::ty::is_copy;
 use clippy_utils::usage::mutated_variables;
 use clippy_utils::visitors::{Descend, for_each_expr_without_closures};
-use clippy_utils::{is_res_lang_ctor, is_trait_method, path_res, path_to_local_id, sym};
+use clippy_utils::{is_trait_method, path_to_local_id, sym};
 use core::ops::ControlFlow;
 use rustc_hir as hir;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -46,7 +47,7 @@ pub(super) fn check<'tcx>(
             // Check if the closure is .filter_map(|x| Some(x))
             if name == sym::filter_map
                 && let hir::ExprKind::Call(expr, args) = body.value.kind
-                && is_res_lang_ctor(cx, path_res(cx, expr), OptionSome)
+                && cx.is_path_lang_ctor(expr, OptionSome)
                 && let hir::ExprKind::Path(_) = args[0].kind
             {
                 span_lint(
@@ -95,7 +96,7 @@ pub(super) fn check<'tcx>(
 fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
     match expr.kind {
         hir::ExprKind::Call(func, args) => {
-            if is_res_lang_ctor(cx, path_res(cx, func), OptionSome) {
+            if cx.is_path_lang_ctor(func, OptionSome) {
                 if path_to_local_id(&args[0], arg_id) {
                     return (false, false);
                 }
@@ -133,9 +134,7 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc
             let else_check = check_expression(cx, arg_id, else_arm);
             (if_check.0 | else_check.0, if_check.1 | else_check.1)
         },
-        hir::ExprKind::Path(ref path) if is_res_lang_ctor(cx, cx.qpath_res(path, expr.hir_id), OptionNone) => {
-            (false, true)
-        },
+        hir::ExprKind::Path(ref path) if cx.is_path_lang_ctor((path, expr.hir_id), OptionNone) => (false, true),
         _ => (true, true),
     }
 }
diff --git a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index cc4448192d3e..14594a7c569c 100644
--- a/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{MaybePath, is_res_lang_ctor, last_path_segment, path_res, sym};
+use clippy_utils::res::PathRes;
+use clippy_utils::{last_path_segment, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, AmbigArg};
 use rustc_lint::LateContext;
@@ -36,26 +37,26 @@ pub(super) fn check(
         return;
     }
 
-    let (constructor, call_args, ty) = if let hir::ExprKind::Call(call, call_args) = init.kind {
-        let Some(qpath) = call.qpath_opt() else { return };
-
-        let args = last_path_segment(qpath).args.map(|args| args.args);
-        let res = cx.qpath_res(qpath, call.hir_id());
-
-        if is_res_lang_ctor(cx, res, hir::LangItem::OptionSome) {
-            (sym::Some, call_args, get_ty_from_args(args, 0))
-        } else if is_res_lang_ctor(cx, res, hir::LangItem::ResultOk) {
-            (sym::Ok, call_args, get_ty_from_args(args, 0))
-        } else if is_res_lang_ctor(cx, res, hir::LangItem::ResultErr) {
-            (sym::Err, call_args, get_ty_from_args(args, 1))
-        } else {
-            return;
-        }
-    } else if is_res_lang_ctor(cx, path_res(cx, init), hir::LangItem::OptionNone) {
-        let call_args: &[hir::Expr<'_>] = &[];
-        (sym::None, call_args, None)
-    } else {
-        return;
+    let (constructor, call_args, ty) = match init.kind {
+        hir::ExprKind::Call(callee, call_args @ [_])
+            if let hir::ExprKind::Path(qpath) = &callee.kind
+                && let Some(did) = cx.path_ctor_parent_id(callee) =>
+        {
+            let args = last_path_segment(qpath).args.map(|args| args.args);
+            if cx.tcx.lang_items().option_some_variant() == Some(did) {
+                (sym::Some, call_args, get_ty_from_args(args, 0))
+            } else if cx.tcx.lang_items().result_ok_variant() == Some(did) {
+                (sym::Ok, call_args, get_ty_from_args(args, 0))
+            } else if cx.tcx.lang_items().result_err_variant() == Some(did) {
+                (sym::Err, call_args, get_ty_from_args(args, 1))
+            } else {
+                return;
+            }
+        },
+        hir::ExprKind::Path(ref qpath) if cx.is_path_lang_ctor((qpath, init.hir_id), hir::LangItem::OptionNone) => {
+            (sym::None, [].as_slice(), None)
+        },
+        _ => return,
     };
 
     let help_message = format!("used `{method}()` on `{constructor}` value");
diff --git a/clippy_lints/src/missing_fields_in_debug.rs b/clippy_lints/src/missing_fields_in_debug.rs
index 8822b32b1c3d..853e54cb27c6 100644
--- a/clippy_lints/src/missing_fields_in_debug.rs
+++ b/clippy_lints/src/missing_fields_in_debug.rs
@@ -1,9 +1,10 @@
 use std::ops::ControlFlow;
 
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::res::PathRes;
+use clippy_utils::sym;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::{Visitable, for_each_expr};
-use clippy_utils::{is_path_lang_item, sym};
 use rustc_ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
@@ -180,7 +181,7 @@ fn check_struct<'tcx>(
         .fields()
         .iter()
         .filter_map(|field| {
-            if field_accesses.contains(&field.ident.name) || is_path_lang_item(cx, field.ty, LangItem::PhantomData) {
+            if field_accesses.contains(&field.ident.name) || cx.is_path_lang_item(field.ty, LangItem::PhantomData) {
                 None
             } else {
                 Some((field.span, "this field is unused"))
diff --git a/clippy_lints/src/needless_question_mark.rs b/clippy_lints/src/needless_question_mark.rs
index 2a2160c3be2d..e0b7d91b8b38 100644
--- a/clippy_lints/src/needless_question_mark.rs
+++ b/clippy_lints/src/needless_question_mark.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::path_res;
+use clippy_utils::res::PathRes;
 use rustc_errors::Applicability;
-use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Block, Body, Expr, ExprKind, LangItem, MatchSource, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -94,8 +93,7 @@ impl LateLintPass<'_> for NeedlessQuestionMark {
 
 fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if let ExprKind::Call(path, [arg]) = expr.kind
-        && let Res::Def(DefKind::Ctor(..), ctor_id) = path_res(cx, path)
-        && let Some(variant_id) = cx.tcx.opt_parent(ctor_id)
+        && let Some(variant_id) = cx.path_ctor_parent_id(path)
         && let variant = if cx.tcx.lang_items().option_some_variant() == Some(variant_id) {
             "Some"
         } else if cx.tcx.lang_items().result_ok_variant() == Some(variant_id) {
diff --git a/clippy_lints/src/non_canonical_impls.rs b/clippy_lints/src/non_canonical_impls.rs
index ba67dc62abbd..8cf7fae048ac 100644
--- a/clippy_lints/src/non_canonical_impls.rs
+++ b/clippy_lints/src/non_canonical_impls.rs
@@ -1,8 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::res::PathRes;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{
-    is_diag_trait_item, is_from_proc_macro, is_res_lang_ctor, last_path_segment, path_res, std_or_core,
-};
+use clippy_utils::{is_diag_trait_item, is_from_proc_macro, last_path_segment, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{Expr, ExprKind, ImplItem, ImplItemKind, LangItem, Node, UnOp};
@@ -256,16 +255,8 @@ fn expr_is_cmp<'tcx>(
     needs_fully_qualified: &mut bool,
 ) -> bool {
     let impl_item_did = impl_item.owner_id.def_id;
-    if let ExprKind::Call(
-        Expr {
-            kind: ExprKind::Path(some_path),
-            hir_id: some_hir_id,
-            ..
-        },
-        [cmp_expr],
-    ) = expr.kind
-    {
-        is_res_lang_ctor(cx, cx.qpath_res(some_path, *some_hir_id), LangItem::OptionSome)
+    if let ExprKind::Call(callee, [cmp_expr]) = expr.kind {
+        cx.is_path_lang_ctor(callee, LangItem::OptionSome)
             // Fix #11178, allow `Self::cmp(self, ..)` too
             && self_cmp_call(cx, cmp_expr, impl_item_did, needs_fully_qualified)
     } else if let ExprKind::MethodCall(_, recv, [], _) = expr.kind {
@@ -287,9 +278,7 @@ fn self_cmp_call<'tcx>(
     needs_fully_qualified: &mut bool,
 ) -> bool {
     match cmp_expr.kind {
-        ExprKind::Call(path, [_, _]) => path_res(cx, path)
-            .opt_def_id()
-            .is_some_and(|def_id| cx.tcx.is_diagnostic_item(sym::ord_cmp_method, def_id)),
+        ExprKind::Call(path, [_, _]) => cx.is_path_diag_item(path, sym::ord_cmp_method),
         ExprKind::MethodCall(_, recv, [_], ..) => {
             let ExprKind::Path(path) = recv.kind else {
                 return false;
diff --git a/clippy_lints/src/non_std_lazy_statics.rs b/clippy_lints/src/non_std_lazy_statics.rs
index 7ecde40aee01..67df7d4addef 100644
--- a/clippy_lints/src/non_std_lazy_statics.rs
+++ b/clippy_lints/src/non_std_lazy_statics.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_hir_and_then};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::paths::{self, PathNS, find_crates, lookup_path_str};
 use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{fn_def_id, is_no_std_crate, path_def_id, sym};
+use clippy_utils::{fn_def_id, is_no_std_crate, sym};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -188,8 +188,8 @@ impl LazyInfo {
     fn from_item(cx: &LateContext<'_>, item: &Item<'_>) -> Option<Self> {
         // Check if item is a `once_cell:sync::Lazy` static.
         if let ItemKind::Static(_, _, ty, body_id) = item.kind
-            && let Some(path_def_id) = path_def_id(cx, ty)
             && let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = ty.kind
+            && let Res::Def(_, path_def_id) = path.res
             && paths::ONCE_CELL_SYNC_LAZY.matches(cx, path_def_id)
         {
             let ty_span_no_args = path_span_without_args(path);
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index a42763172f56..13b589439856 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{get_expr_use_or_unification_node, path_def_id, path_to_local, path_to_local_id};
+use clippy_utils::res::PathRes;
+use clippy_utils::{get_expr_use_or_unification_node, path_to_local, path_to_local_id};
 use core::cell::Cell;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
@@ -290,9 +291,8 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                     Some((Node::Expr(parent), child_id)) => match parent.kind {
                         // Recursive call. Track which index the parameter is used in.
                         ExprKind::Call(callee, args)
-                            if path_def_id(cx, callee).is_some_and(|id| {
-                                id == param.fn_id && has_matching_args(param.fn_kind, typeck.node_args(callee.hir_id))
-                            }) =>
+                            if cx.is_path_item(callee, param.fn_id)
+                                && has_matching_args(param.fn_kind, typeck.node_args(callee.hir_id)) =>
                         {
                             if let Some(idx) = args.iter().position(|arg| arg.hir_id == child_id) {
                                 param.uses.push(Usage::new(span, idx));
diff --git a/clippy_lints/src/operators/cmp_owned.rs b/clippy_lints/src/operators/cmp_owned.rs
index 604f8f5da0b8..7698ae671a62 100644
--- a/clippy_lints/src/operators/cmp_owned.rs
+++ b/clippy_lints/src/operators/cmp_owned.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::path_def_id;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
 use rustc_errors::Applicability;
@@ -47,11 +47,11 @@ fn check_op(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool)
             (arg, arg.span)
         },
         ExprKind::Call(path, [arg])
-            if path_def_id(cx, path).is_some_and(|did| match cx.tcx.get_diagnostic_name(did) {
+            if match cx.path_diag_name(path) {
                 Some(sym::from_str_method) => true,
                 Some(sym::from_fn) => !is_copy(cx, typeck.expr_ty(expr)),
                 _ => false,
-            }) =>
+            } =>
         {
             (arg, arg.span)
         },
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index 3483f3081a58..0a3d41f84e52 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,20 +1,20 @@
 use std::ops::ControlFlow;
 
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_copy;
 use clippy_utils::{
     CaptureKind, can_move_expr_to_closure, eager_or_lazy, expr_requires_coercion, higher, is_else_clause,
-    is_in_const_context, is_res_lang_ctor, peel_blocks, peel_hir_expr_while,
+    is_in_const_context, peel_blocks, peel_hir_expr_while,
 };
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
+use rustc_hir::LangItem::{OptionNone, ResultErr};
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{Visitor, walk_expr, walk_path};
 use rustc_hir::{
-    Arm, BindingMode, Expr, ExprKind, HirId, MatchSource, Mutability, Node, Pat, PatExpr, PatExprKind, PatKind, Path,
-    QPath, UnOp,
+    Arm, BindingMode, Expr, ExprKind, HirId, MatchSource, Mutability, Node, Pat, PatKind, Path, QPath, UnOp,
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
@@ -312,11 +312,12 @@ impl<'tcx> Visitor<'tcx> for ReferenceVisitor<'_, 'tcx> {
 }
 
 fn try_get_inner_pat_and_is_result<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>) -> Option<(&'tcx Pat<'tcx>, bool)> {
-    if let PatKind::TupleStruct(ref qpath, [inner_pat], ..) = pat.kind {
-        let res = cx.qpath_res(qpath, pat.hir_id);
-        if is_res_lang_ctor(cx, res, OptionSome) {
+    if let PatKind::TupleStruct(ref qpath, [inner_pat], ..) = pat.kind
+        && let Some(did) = cx.path_ctor_parent_id((qpath, pat.hir_id))
+    {
+        if cx.tcx.lang_items().option_some_variant() == Some(did) {
             return Some((inner_pat, false));
-        } else if is_res_lang_ctor(cx, res, ResultOk) {
+        } else if cx.tcx.lang_items().result_ok_variant() == Some(did) {
             return Some((inner_pat, true));
         }
     }
@@ -375,14 +376,9 @@ fn try_convert_match<'tcx>(
 
 fn is_none_or_err_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
     match arm.pat.kind {
-        PatKind::Expr(PatExpr {
-            kind: PatExprKind::Path(qpath),
-            hir_id,
-            ..
-        }) => is_res_lang_ctor(cx, cx.qpath_res(qpath, *hir_id), OptionNone),
+        PatKind::Expr(e) => cx.is_path_lang_ctor(e, OptionNone),
         PatKind::TupleStruct(ref qpath, [first_pat], _) => {
-            is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), ResultErr)
-                && matches!(first_pat.kind, PatKind::Wild)
+            cx.is_path_lang_ctor((qpath, arm.pat.hir_id), ResultErr) && matches!(first_pat.kind, PatKind::Wild)
         },
         PatKind::Wild => true,
         _ => false,
diff --git a/clippy_lints/src/partialeq_to_none.rs b/clippy_lints/src/partialeq_to_none.rs
index 9b9024c81057..518aa5388eed 100644
--- a/clippy_lints/src/partialeq_to_none.rs
+++ b/clippy_lints/src/partialeq_to_none.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_res_lang_ctor, path_res, peel_hir_expr_refs, peel_ref_operators, sugg};
+use clippy_utils::{peel_hir_expr_refs, peel_ref_operators, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
@@ -52,8 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for PartialeqToNone {
 
         // If the expression is a literal `Option::None`
         let is_none_ctor = |expr: &Expr<'_>| {
-            !expr.span.from_expansion()
-                && is_res_lang_ctor(cx, path_res(cx, peel_hir_expr_refs(expr).0), LangItem::OptionNone)
+            !expr.span.from_expansion() && cx.is_path_lang_ctor(peel_hir_expr_refs(expr).0, LangItem::OptionNone)
         };
 
         let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 9eed46460a61..910a8941cb5d 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::visitors::contains_unsafe_block;
-use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_def_id, path_to_local, std_or_core, sym};
+use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_to_local, std_or_core, sym};
 use hir::LifetimeKind;
 use rustc_abi::ExternAbi;
 use rustc_errors::{Applicability, MultiSpan};
@@ -742,8 +743,7 @@ fn get_lifetimes<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Vec<(&'tcx Lifetime, Option<M
 
 fn is_null_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     if let ExprKind::Call(pathexp, []) = expr.kind {
-        path_def_id(cx, pathexp)
-            .is_some_and(|id| matches!(cx.tcx.get_diagnostic_name(id), Some(sym::ptr_null | sym::ptr_null_mut)))
+        matches!(cx.path_diag_name(pathexp), Some(sym::ptr_null | sym::ptr_null_mut))
     } else {
         false
     }
diff --git a/clippy_lints/src/pub_underscore_fields.rs b/clippy_lints/src/pub_underscore_fields.rs
index 66c59cb70d36..e032dc299a99 100644
--- a/clippy_lints/src/pub_underscore_fields.rs
+++ b/clippy_lints/src/pub_underscore_fields.rs
@@ -2,7 +2,7 @@ use clippy_config::Conf;
 use clippy_config::types::PubUnderscoreFieldsBehaviour;
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::is_path_lang_item;
+use clippy_utils::res::PathRes;
 use rustc_hir::{FieldDef, Item, ItemKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -76,7 +76,7 @@ impl<'tcx> LateLintPass<'tcx> for PubUnderscoreFields {
                 // We ignore fields that have `#[doc(hidden)]`.
                 && !is_doc_hidden(cx.tcx.hir_attrs(field.hir_id))
                 // We ignore fields that are `PhantomData`.
-                && !is_path_lang_item(cx, field.ty, LangItem::PhantomData)
+                && !cx.is_path_lang_item(field.ty, LangItem::PhantomData)
             {
                 span_lint_hir_and_then(
                     cx,
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index de12a25b03df..c1e7d03db4d6 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -4,12 +4,13 @@ use clippy_config::Conf;
 use clippy_config::types::MatchLintBehaviour;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{
-    eq_expr_value, higher, is_else_clause, is_in_const_context, is_lint_allowed, is_path_lang_item, is_res_lang_ctor,
-    pat_and_expr_can_be_question_mark, path_res, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
+    eq_expr_value, higher, is_else_clause, is_in_const_context, is_lint_allowed, is_res_lang_ctor,
+    pat_and_expr_can_be_question_mark, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
     span_contains_cfg, span_contains_comment, sym,
 };
 use rustc_errors::Applicability;
@@ -218,15 +219,15 @@ fn is_early_return(smbl: Symbol, cx: &LateContext<'_>, if_block: &IfBlockType<'_
                     sym::Option => {
                         // We only need to check `if let Some(x) = option` not `if let None = option`,
                         // because the later one will be suggested as `if option.is_none()` thus causing conflict.
-                        is_res_lang_ctor(cx, res, OptionSome)
+                        is_res_lang_ctor(cx.tcx, res, OptionSome)
                             && if_else.is_some()
                             && expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, None)
                     },
                     sym::Result => {
-                        (is_res_lang_ctor(cx, res, ResultOk)
+                        (is_res_lang_ctor(cx.tcx, res, ResultOk)
                             && if_else.is_some()
                             && expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, Some(let_pat_sym)))
-                            || is_res_lang_ctor(cx, res, ResultErr)
+                            || is_res_lang_ctor(cx.tcx, res, ResultErr)
                                 && expr_return_none_or_err(smbl, cx, if_then, let_expr, Some(let_pat_sym))
                                 && if_else.is_none()
                     },
@@ -246,7 +247,7 @@ fn expr_return_none_or_err(
     match peel_blocks_with_stmt(expr).kind {
         ExprKind::Ret(Some(ret_expr)) => expr_return_none_or_err(smbl, cx, ret_expr, cond_expr, err_sym),
         ExprKind::Path(ref qpath) => match smbl {
-            sym::Option => is_res_lang_ctor(cx, cx.qpath_res(qpath, expr.hir_id), OptionNone),
+            sym::Option => cx.is_path_lang_ctor((qpath, expr.hir_id), OptionNone),
             sym::Result => path_to_local(expr).is_some() && path_to_local(expr) == path_to_local(cond_expr),
             _ => false,
         },
@@ -341,7 +342,7 @@ fn extract_ctor_call<'a, 'tcx>(
     pat: &'a Pat<'tcx>,
 ) -> Option<&'a Pat<'tcx>> {
     if let PatKind::TupleStruct(variant_path, [val_binding], _) = &pat.kind
-        && is_res_lang_ctor(cx, cx.qpath_res(variant_path, pat.hir_id), expected_ctor)
+        && cx.is_path_lang_ctor((variant_path, pat.hir_id), expected_ctor)
     {
         Some(val_binding)
     } else {
@@ -392,7 +393,7 @@ fn check_arm_is_none_or_err<'tcx>(cx: &LateContext<'tcx>, mode: TryMode, arm: &A
                 // check `=> return Err(...)`
                 && let ExprKind::Ret(Some(wrapped_ret_expr)) = arm_body.kind
                 && let ExprKind::Call(ok_ctor, [ret_expr]) = wrapped_ret_expr.kind
-                && is_res_lang_ctor(cx, path_res(cx, ok_ctor), ResultErr)
+                && cx.is_path_lang_ctor(ok_ctor, ResultErr)
                 // check `...` is `val` from binding
                 && path_to_local_id(ret_expr, ok_val)
             {
@@ -403,10 +404,10 @@ fn check_arm_is_none_or_err<'tcx>(cx: &LateContext<'tcx>, mode: TryMode, arm: &A
         },
         TryMode::Option => {
             // Check the pat is `None`
-            if is_res_lang_ctor(cx, path_res(cx, arm.pat), OptionNone)
+            if cx.is_path_lang_ctor(arm.pat, OptionNone)
                 // Check `=> return None`
                 && let ExprKind::Ret(Some(ret_expr)) = arm_body.kind
-                && is_res_lang_ctor(cx, path_res(cx, ret_expr), OptionNone)
+                && cx.is_path_lang_ctor(ret_expr, OptionNone)
                 && !ret_expr.span.from_expansion()
             {
                 true
@@ -506,7 +507,7 @@ fn is_try_block(cx: &LateContext<'_>, bl: &Block<'_>) -> bool {
     if let Some(expr) = bl.expr
         && let ExprKind::Call(callee, [_]) = expr.kind
     {
-        is_path_lang_item(cx, callee, LangItem::TryTraitFromOutput)
+        cx.is_path_lang_item(callee, LangItem::TryTraitFromOutput)
     } else {
         false
     }
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 03d00ba849f3..27caa3f3af92 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -2,12 +2,12 @@ use clippy_config::Conf;
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{SpanRangeExt, snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{
-    expr_use_ctxt, fn_def_id, get_parent_expr, higher, is_in_const_context, is_integer_const, is_path_lang_item,
-    path_to_local,
+    expr_use_ctxt, fn_def_id, get_parent_expr, higher, is_in_const_context, is_integer_const, path_to_local,
 };
 use rustc_ast::Mutability;
 use rustc_ast::ast::RangeLimits;
@@ -370,7 +370,7 @@ fn can_switch_ranges<'tcx>(
     // Check if `expr` is the argument of a compiler-generated `IntoIter::into_iter(expr)`
     if let ExprKind::Call(func, [arg]) = parent_expr.kind
         && arg.hir_id == use_ctxt.child_id
-        && is_path_lang_item(cx, func, LangItem::IntoIterIntoIter)
+        && cx.is_path_lang_item(func, LangItem::IntoIterIntoIter)
     {
         return true;
     }
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 89d945161f62..a33068b75faf 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -2,9 +2,9 @@ use std::fmt::Display;
 
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::paths::PathLookup;
+use clippy_utils::paths::{self, PathLookup};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::SpanRangeExt;
-use clippy_utils::{path_def_id, paths};
 use rustc_ast::ast::{LitKind, StrStyle};
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{BorrowKind, Expr, ExprKind, OwnerId};
@@ -138,7 +138,7 @@ impl<'tcx> LateLintPass<'tcx> for Regex {
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Call(fun, [arg]) = expr.kind
-            && let Some(def_id) = path_def_id(cx, fun)
+            && let Some(def_id) = cx.path_def_id(fun)
             && let Some(regex_kind) = self.definitions.get(&def_id)
         {
             if let Some(&(loop_item_id, loop_span)) = self.loop_stack.last()
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index e0c93153a77a..58e6cf9b66ae 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{SpanRangeExt, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{
-    binary_expr_needs_parentheses, fn_def_id, is_from_proc_macro, is_inside_let_else, is_res_lang_ctor,
-    leaks_droppable_temporary_with_limited_lifetime, path_res, path_to_local_id, span_contains_cfg,
-    span_find_starting_semi, sym,
+    binary_expr_needs_parentheses, fn_def_id, is_from_proc_macro, is_inside_let_else,
+    leaks_droppable_temporary_with_limited_lifetime, path_to_local_id, span_contains_cfg, span_find_starting_semi, sym,
 };
 use core::ops::ControlFlow;
 use rustc_ast::MetaItemInner;
@@ -200,7 +200,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             && let ExprKind::Match(maybe_cons, _, MatchSource::TryDesugar(_)) = ret.kind
             && let ExprKind::Call(_, [maybe_result_err]) = maybe_cons.kind
             && let ExprKind::Call(maybe_constr, _) = maybe_result_err.kind
-            && is_res_lang_ctor(cx, path_res(cx, maybe_constr), ResultErr)
+            && cx.is_path_lang_ctor(maybe_constr, ResultErr)
 
             // Ensure this is not the final stmt, otherwise removing it would cause a compile error
             && let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir_get_parent_item(expr.hir_id))
diff --git a/clippy_lints/src/single_option_map.rs b/clippy_lints/src/single_option_map.rs
index cc497c97a472..63dc727f6aaa 100644
--- a/clippy_lints/src/single_option_map.rs
+++ b/clippy_lints/src/single_option_map.rs
@@ -1,7 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{path_res, peel_blocks};
-use rustc_hir::def::Res;
+use clippy_utils::{path_to_local, peel_blocks};
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, ExprKind, FnDecl, FnRetTy};
@@ -56,9 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for SingleOptionMap {
                 && method_name.ident.name == sym::map
                 && let callee_type = cx.typeck_results().expr_ty(callee)
                 && is_type_diagnostic_item(cx, callee_type, sym::Option)
-                && let ExprKind::Path(_path) = callee.kind
-                && let Res::Local(_id) = path_res(cx, callee)
-                && matches!(path_res(cx, callee), Res::Local(_id))
+                && path_to_local(callee).is_some()
                 && !matches!(args[0].kind, ExprKind::Path(_))
             {
                 if let ExprKind::Closure(closure) = args[0].kind {
@@ -70,8 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for SingleOptionMap {
                         return;
                     } else if let ExprKind::MethodCall(_segment, receiver, method_args, _span) = value.kind
                         && matches!(receiver.kind, ExprKind::Path(_))
-                        && method_args.iter().all(|arg| matches!(arg.kind, ExprKind::Path(_)))
-                        && method_args.iter().all(|arg| matches!(path_res(cx, arg), Res::Local(_)))
+                        && method_args.iter().all(|arg| path_to_local(arg).is_some())
                     {
                         return;
                     }
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 60d923bcd77e..63dda6d721ed 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{path_def_id, peel_middle_ty_refs};
+use clippy_utils::peel_middle_ty_refs;
+use clippy_utils::res::PathRes;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -56,8 +57,7 @@ declare_lint_pass!(SizeOfRef => [SIZE_OF_REF]);
 impl LateLintPass<'_> for SizeOfRef {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Call(path, [arg]) = expr.kind
-            && let Some(def_id) = path_def_id(cx, path)
-            && cx.tcx.is_diagnostic_item(sym::mem_size_of_val, def_id)
+            && cx.is_path_diag_item(path, sym::mem_size_of_val)
             && let arg_ty = cx.typeck_results().expr_ty(arg)
             && peel_middle_ty_refs(arg_ty).1 > 1
         {
diff --git a/clippy_lints/src/slow_vector_initialization.rs b/clippy_lints/src/slow_vector_initialization.rs
index f497d0700b8e..b5a0ff2e53fc 100644
--- a/clippy_lints/src/slow_vector_initialization.rs
+++ b/clippy_lints/src/slow_vector_initialization.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::matching_root_macro_call;
+use clippy_utils::res::PathRes;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    SpanlessEq, get_enclosing_block, is_integer_literal, is_path_diagnostic_item, path_to_local, path_to_local_id,
-    span_contains_comment, sym,
+    SpanlessEq, get_enclosing_block, is_integer_literal, path_to_local, path_to_local_id, span_contains_comment, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{Visitor, walk_block, walk_expr, walk_stmt};
@@ -149,10 +149,10 @@ impl SlowVectorInit {
         }
 
         if let ExprKind::Call(func, [len_expr]) = expr.kind
-            && is_path_diagnostic_item(cx, func, sym::vec_with_capacity)
+            && cx.is_path_diag_item(func, sym::vec_with_capacity)
         {
             Some(InitializedSize::Initialized(len_expr))
-        } else if matches!(expr.kind, ExprKind::Call(func, []) if is_path_diagnostic_item(cx, func, sym::vec_new)) {
+        } else if matches!(expr.kind, ExprKind::Call(func, []) if cx.is_path_diag_item(func, sym::vec_new)) {
             Some(InitializedSize::Uninitialized)
         } else {
             None
@@ -301,7 +301,7 @@ impl<'tcx> VectorInitializationVisitor<'_, 'tcx> {
     /// Returns `true` if given expression is `repeat(0)`
     fn is_repeat_zero(&self, expr: &Expr<'_>) -> bool {
         if let ExprKind::Call(fn_expr, [repeat_arg]) = expr.kind
-            && is_path_diagnostic_item(self.cx, fn_expr, sym::iter_repeat)
+            && self.cx.is_path_diag_item(fn_expr, sym::iter_repeat)
             && is_integer_literal(repeat_arg, 0)
         {
             true
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 57d5900b045e..c34fdcdf39ae 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_lang_item;
 use clippy_utils::{
-    SpanlessEq, get_expr_use_or_unification_node, get_parent_expr, is_lint_allowed, method_calls, path_def_id,
-    peel_blocks, sym,
+    SpanlessEq, get_expr_use_or_unification_node, get_parent_expr, is_lint_allowed, method_calls, peel_blocks, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -251,9 +251,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
         use rustc_ast::LitKind;
 
         if let ExprKind::Call(fun, [bytes_arg]) = e.kind
-            // Find `std::str::converts::from_utf8` or `std::primitive::str::from_utf8`
-            && let Some(sym::str_from_utf8 | sym::str_inherent_from_utf8) =
-                path_def_id(cx, fun).and_then(|id| cx.tcx.get_diagnostic_name(id))
+            && matches!(cx.path_diag_name(fun), Some(sym::str_from_utf8 | sym::str_inherent_from_utf8))
 
             // Find string::as_bytes
             && let ExprKind::AddrOf(BorrowKind::Ref, _, args) = bytes_arg.kind
diff --git a/clippy_lints/src/swap_ptr_to_ref.rs b/clippy_lints/src/swap_ptr_to_ref.rs
index ff196355a2e3..8fdcd4c53fd6 100644
--- a/clippy_lints/src/swap_ptr_to_ref.rs
+++ b/clippy_lints/src/swap_ptr_to_ref.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::path_def_id;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_context;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, UnOp};
@@ -41,8 +41,7 @@ declare_lint_pass!(SwapPtrToRef => [SWAP_PTR_TO_REF]);
 impl LateLintPass<'_> for SwapPtrToRef {
     fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
         if let ExprKind::Call(fn_expr, [arg1, arg2]) = e.kind
-            && let Some(fn_id) = path_def_id(cx, fn_expr)
-            && cx.tcx.is_diagnostic_item(sym::mem_swap, fn_id)
+            && cx.is_path_diag_item(fn_expr, sym::mem_swap)
             && let ctxt = e.span.ctxt()
             && let (from_ptr1, arg1_span) = is_ptr_to_ref(cx, arg1, ctxt)
             && let (from_ptr2, arg2_span) = is_ptr_to_ref(cx, arg2, ctxt)
diff --git a/clippy_lints/src/to_digit_is_some.rs b/clippy_lints/src/to_digit_is_some.rs
index 3e847543e1c1..ccbb2b80a4ff 100644
--- a/clippy_lints/src/to_digit_is_some.rs
+++ b/clippy_lints/src/to_digit_is_some.rs
@@ -1,8 +1,9 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{is_in_const_context, is_path_diagnostic_item, sym};
+use clippy_utils::{is_in_const_context, sym};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -62,7 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for ToDigitIsSome {
                     }
                 },
                 hir::ExprKind::Call(to_digits_call, [char_arg, radix_arg]) => {
-                    if is_path_diagnostic_item(cx, to_digits_call, sym::char_to_digit) {
+                    if cx.is_path_diag_item(to_digits_call, sym::char_to_digit) {
                         Some((false, char_arg, radix_arg))
                     } else {
                         None
diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index 7acf3be51fb7..02591e53b006 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -1,6 +1,7 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
+use clippy_utils::is_integer_literal;
+use clippy_utils::res::PathRes;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
@@ -40,7 +41,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
         },
         // Catching:
         // `std::mem::transmute(std::ptr::null::<i32>())`
-        ExprKind::Call(func1, []) if is_path_diagnostic_item(cx, func1, sym::ptr_null) => {
+        ExprKind::Call(func1, []) if cx.is_path_diag_item(func1, sym::ptr_null) => {
             lint_expr(cx, expr);
             true
         },
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
index 544014bd32b3..05223d3081c6 100644
--- a/clippy_lints/src/transmute/transmuting_null.rs
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -1,6 +1,7 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
+use clippy_utils::is_integer_literal;
+use clippy_utils::res::PathRes;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Ty;
@@ -35,7 +36,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
     // Catching:
     // `std::mem::transmute(std::ptr::null::<i32>())`
     if let ExprKind::Call(func1, []) = arg.kind
-        && is_path_diagnostic_item(cx, func1, sym::ptr_null)
+        && cx.is_path_diag_item(func1, sym::ptr_null)
     {
         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
         return true;
diff --git a/clippy_lints/src/types/box_collection.rs b/clippy_lints/src/types/box_collection.rs
index 24fe4e08a5b4..0b7c7b32f3c4 100644
--- a/clippy_lints/src/types/box_collection.rs
+++ b/clippy_lints/src/types/box_collection.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{path_def_id, qpath_generic_tys};
+use clippy_utils::qpath_generic_tys;
+use clippy_utils::res::PathRes;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
@@ -33,7 +34,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
 
 fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Symbol> {
     let param = qpath_generic_tys(qpath).next()?;
-    let id = path_def_id(cx, param)?;
+    let id = cx.path_def_id(param)?;
     cx.tcx
         .get_diagnostic_name(id)
         .filter(|&name| {
diff --git a/clippy_lints/src/types/option_option.rs b/clippy_lints/src/types/option_option.rs
index d12d14f2b141..1c9228bf8111 100644
--- a/clippy_lints/src/types/option_option.rs
+++ b/clippy_lints/src/types/option_option.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{path_def_id, qpath_generic_tys};
+use clippy_utils::qpath_generic_tys;
+use clippy_utils::res::PathRes;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
@@ -10,7 +11,7 @@ use super::OPTION_OPTION;
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if cx.tcx.is_diagnostic_item(sym::Option, def_id)
         && let Some(arg) = qpath_generic_tys(qpath).next()
-        && path_def_id(cx, arg) == Some(def_id)
+        && cx.is_path_item(arg, def_id)
     {
         span_lint(
             cx,
diff --git a/clippy_lints/src/types/owned_cow.rs b/clippy_lints/src/types/owned_cow.rs
index 8933994d1855..824aee551af0 100644
--- a/clippy_lints/src/types/owned_cow.rs
+++ b/clippy_lints/src/types/owned_cow.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_opt;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
@@ -30,23 +31,20 @@ pub(super) fn check(cx: &LateContext<'_>, qpath: &hir::QPath<'_>, def_id: DefId)
 }
 
 fn replacement(cx: &LateContext<'_>, cty: &hir::Ty<'_>) -> Option<(Span, String)> {
-    if clippy_utils::is_path_lang_item(cx, cty, hir::LangItem::String) {
+    if cx.is_path_lang_item(cty, hir::LangItem::String) {
         return Some((cty.span, "str".into()));
     }
-    if clippy_utils::is_path_diagnostic_item(cx, cty, sym::Vec) {
-        return if let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = cty.kind
-            && let [.., last_seg] = path.segments
-            && let Some(args) = last_seg.args
-            && let [t, ..] = args.args
-            && let Some(snip) = snippet_opt(cx, t.span())
+    match cx.path_diag_name(cty) {
+        Some(sym::Vec)
+            if let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = cty.kind
+                && let [.., last_seg] = path.segments
+                && let Some(args) = last_seg.args
+                && let [t, ..] = args.args
+                && let Some(snip) = snippet_opt(cx, t.span()) =>
         {
             Some((cty.span, format!("[{snip}]")))
-        } else {
-            None
-        };
-    }
-    if clippy_utils::is_path_diagnostic_item(cx, cty, sym::cstring_type) {
-        return Some((
+        },
+        Some(sym::cstring_type) => Some((
             cty.span,
             (if clippy_utils::is_no_std_crate(cx) {
                 "core::ffi::CStr"
@@ -54,13 +52,9 @@ fn replacement(cx: &LateContext<'_>, cty: &hir::Ty<'_>) -> Option<(Span, String)
                 "std::ffi::CStr"
             })
             .into(),
-        ));
-    }
-    // Neither OsString nor PathBuf are available outside std
-    for (diag, repl) in [(sym::OsString, "std::ffi::OsStr"), (sym::PathBuf, "std::path::Path")] {
-        if clippy_utils::is_path_diagnostic_item(cx, cty, diag) {
-            return Some((cty.span, repl.into()));
-        }
+        )),
+        Some(sym::OsString) => Some((cty.span, "std::ffi::OsStr".into())),
+        Some(sym::PathBuf) => Some((cty.span, "std::path::Path".into())),
+        _ => None,
     }
-    None
 }
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index c4fd0fbf87a9..61b275410d40 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::qpath_generic_tys;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath, TyKind};
@@ -28,8 +29,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
             let Some(ty) = qpath_generic_tys(qpath).next() else {
                 return false;
             };
-            let Some(id) = path_def_id(cx, ty) else { return false };
-            if !cx.tcx.is_diagnostic_item(sym::Vec, id) {
+            if !cx.is_path_diag_item(ty, sym::Vec) {
                 return false;
             }
             let TyKind::Path(qpath) = &ty.kind else { return false };
@@ -70,8 +70,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 },
             );
         } else if let Some(ty) = qpath_generic_tys(qpath).next() {
-            let Some(id) = path_def_id(cx, ty) else { return false };
-            if !cx.tcx.is_diagnostic_item(sym::Vec, id) {
+            if !cx.is_path_diag_item(ty, sym::Vec) {
                 return false;
             }
             let TyKind::Path(qpath) = &ty.kind else { return false };
@@ -106,7 +105,7 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
 
 fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
     let ty = qpath_generic_tys(qpath).next()?;
-    let id = path_def_id(cx, ty)?;
+    let id = cx.path_def_id(ty)?;
     let path = match cx.tcx.get_diagnostic_name(id) {
         Some(sym::OsString) => "std::ffi::OsStr",
         Some(sym::PathBuf) => "std::path::Path",
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index 7b13debc01ef..86eb7acf79e6 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{path_def_id, qpath_generic_tys};
+use clippy_utils::qpath_generic_tys;
+use clippy_utils::res::PathRes;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath};
 use rustc_lint::LateContext;
@@ -10,8 +11,7 @@ use super::RC_MUTEX;
 pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
     if cx.tcx.is_diagnostic_item(sym::Rc, def_id)
         && let Some(arg) = qpath_generic_tys(qpath).next()
-        && let Some(id) = path_def_id(cx, arg)
-        && cx.tcx.is_diagnostic_item(sym::Mutex, id)
+        && cx.is_path_diag_item(arg, sym::Mutex)
     {
         #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
         span_lint_and_then(cx, RC_MUTEX, hir_ty.span, "usage of `Rc<Mutex<_>>`", |diag| {
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
index 0ba51daf027d..84df86d335b1 100644
--- a/clippy_lints/src/types/redundant_allocation.rs
+++ b/clippy_lints/src/types/redundant_allocation.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::qpath_generic_tys;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::{snippet, snippet_with_applicability};
-use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath, TyKind};
@@ -40,7 +41,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>, qpath:
     let Some(ty) = qpath_generic_tys(qpath).next() else {
         return false;
     };
-    let Some(id) = path_def_id(cx, ty) else { return false };
+    let Some(id) = cx.path_def_id(ty) else { return false };
     let (inner_sym, ty) = match cx.tcx.get_diagnostic_name(id) {
         Some(sym::Arc) => ("Arc", ty),
         Some(sym::Rc) => ("Rc", ty),
diff --git a/clippy_lints/src/unconditional_recursion.rs b/clippy_lints/src/unconditional_recursion.rs
index e843e169113e..9fca97f527ff 100644
--- a/clippy_lints/src/unconditional_recursion.rs
+++ b/clippy_lints/src/unconditional_recursion.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{expr_or_init, fn_def_id_with_node_args, path_def_id};
+use clippy_utils::res::PathRes;
+use clippy_utils::{expr_or_init, fn_def_id_with_node_args};
 use rustc_ast::BinOpKind;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir as hir;
@@ -317,7 +318,7 @@ where
         if let ExprKind::Call(f, _) = expr.kind
             && let ExprKind::Path(qpath) = f.kind
             && is_default_method_on_current_ty(self.cx.tcx, qpath, self.implemented_ty_id)
-            && let Some(method_def_id) = path_def_id(self.cx, f)
+            && let Some(method_def_id) = self.cx.path_def_id(f)
             && let Some(trait_def_id) = self.cx.tcx.trait_of_assoc(method_def_id)
             && self.cx.tcx.is_diagnostic_item(sym::Default, trait_def_id)
         {
diff --git a/clippy_lints/src/unnecessary_literal_bound.rs b/clippy_lints/src/unnecessary_literal_bound.rs
index 9f107fbeec03..330d359e3e76 100644
--- a/clippy_lints/src/unnecessary_literal_bound.rs
+++ b/clippy_lints/src/unnecessary_literal_bound.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::path_res;
+use clippy_utils::res::PathRes;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -138,7 +138,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryLiteralBound {
             return;
         };
 
-        if path_res(cx, inner_hir_ty) != Res::PrimTy(PrimTy::Str) {
+        if cx.path_res(inner_hir_ty) != Res::PrimTy(PrimTy::Str) {
             return;
         }
 
diff --git a/clippy_lints/src/unnecessary_wraps.rs b/clippy_lints/src/unnecessary_wraps.rs
index 849c0b438a5a..245cdb87bdcf 100644
--- a/clippy_lints/src/unnecessary_wraps.rs
+++ b/clippy_lints/src/unnecessary_wraps.rs
@@ -2,9 +2,10 @@ use std::borrow::Cow;
 
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::res::PathRes;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::find_all_ret_expressions;
-use clippy_utils::{contains_return, is_res_lang_ctor, path_res, return_ty};
+use clippy_utils::{contains_return, return_ty};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionSome, ResultOk};
 use rustc_hir::intravisit::FnKind;
@@ -122,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryWraps {
             if !ret_expr.span.from_expansion()
                 // Check if a function call.
                 && let ExprKind::Call(func, [arg]) = ret_expr.kind
-                && is_res_lang_ctor(cx, path_res(cx, func), lang_item)
+                && cx.is_path_lang_ctor(func, lang_item)
                 // Make sure the function argument does not contain a return expression.
                 && !contains_return(arg)
             {
diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index af3ad4566c46..219d0f2cb2f6 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::macros::{is_panic, root_macro_call_first_node};
-use clippy_utils::{is_res_lang_ctor, paths, peel_blocks, sym};
+use clippy_utils::res::PathRes;
+use clippy_utils::{paths, peel_blocks, sym};
 use hir::{ExprKind, HirId, PatKind};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
@@ -135,8 +136,8 @@ fn non_consuming_err_arm<'a>(cx: &LateContext<'a>, arm: &hir::Arm<'a>) -> bool {
         return false;
     }
 
-    if let PatKind::TupleStruct(ref path, [inner_pat], _) = arm.pat.kind {
-        return is_res_lang_ctor(cx, cx.qpath_res(path, inner_pat.hir_id), hir::LangItem::ResultErr);
+    if let PatKind::TupleStruct(ref path, [_], _) = arm.pat.kind {
+        return cx.is_path_lang_ctor((path, arm.pat.hir_id), hir::LangItem::ResultErr);
     }
 
     false
@@ -203,7 +204,7 @@ fn is_ok_wild_or_dotdot_pattern<'a>(cx: &LateContext<'a>, pat: &hir::Pat<'a>) ->
 
     if let PatKind::TupleStruct(ref path, inner_pat, _) = pat.kind
         // we check against Result::Ok to avoid linting on Err(_) or something else.
-        && is_res_lang_ctor(cx, cx.qpath_res(path, pat.hir_id), hir::LangItem::ResultOk)
+        && cx.is_path_lang_ctor((path, pat.hir_id), hir::LangItem::ResultOk)
     {
         if matches!(inner_pat, []) {
             return true;
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 2113cb92137e..6d2e09153c9a 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -1,4 +1,5 @@
-use clippy_utils::{MaybePath, get_attr, higher, path_def_id, sym};
+use clippy_utils::res::{MaybeQPath, PathRes};
+use clippy_utils::{get_attr, higher, sym};
 use itertools::Itertools;
 use rustc_ast::LitIntType;
 use rustc_ast::ast::{LitFloatType, LitKind};
@@ -269,10 +270,10 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         chain!(self, "{symbol}.as_str() == {:?}", symbol.value.as_str());
     }
 
-    fn qpath<'p>(&self, qpath: &Binding<&QPath<'_>>, has_hir_id: &Binding<&impl MaybePath<'p>>) {
+    fn qpath(&self, qpath: &Binding<&QPath<'_>>, has_hir_id: &str, hir_id: HirId) {
         if let QPath::LangItem(lang_item, ..) = *qpath.value {
             chain!(self, "matches!({qpath}, QPath::LangItem(LangItem::{lang_item:?}, _))");
-        } else if let Some(def_id) = self.cx.qpath_res(qpath.value, has_hir_id.value.hir_id()).opt_def_id()
+        } else if let Some(def_id) = self.cx.qpath_res(qpath.value, hir_id).opt_def_id()
             && !def_id.is_local()
         {
             bind!(self, def_id);
@@ -292,14 +293,14 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
         }
     }
 
-    fn maybe_path<'p>(&self, path: &Binding<&impl MaybePath<'p>>) {
-        if let Some(id) = path_def_id(self.cx, path.value)
+    fn maybe_path<'b>(&self, path: &Binding<impl Copy + MaybeQPath<'b>>) {
+        if let Some(id) = self.cx.path_def_id(path.value)
             && !id.is_local()
         {
             if let Some(lang) = self.cx.tcx.lang_items().from_def_id(id) {
-                chain!(self, "is_path_lang_item(cx, {path}, LangItem::{}", lang.name());
+                chain!(self, "cx.is_path_lang_item({path}, LangItem::{}", lang.name());
             } else if let Some(name) = self.cx.tcx.get_diagnostic_name(id) {
-                chain!(self, "is_path_diagnostic_item(cx, {path}, sym::{name})");
+                chain!(self, "cx.is_path_diag_item({path}, sym::{name})");
             } else {
                 chain!(
                     self,
@@ -672,7 +673,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                     StructTailExpr::None | StructTailExpr::DefaultFields(_) => None,
                 });
                 kind!("Struct({qpath}, {fields}, {base})");
-                self.qpath(qpath, expr);
+                self.qpath(qpath, &expr.name, expr.value.hir_id);
                 self.slice(fields, |field| {
                     self.ident(field!(field.ident));
                     self.expr(field!(field.expr));
@@ -757,7 +758,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             PatKind::Struct(ref qpath, fields, ignore) => {
                 bind!(self, qpath, fields);
                 kind!("Struct(ref {qpath}, {fields}, {ignore})");
-                self.qpath(qpath, pat);
+                self.qpath(qpath, &pat.name, pat.value.hir_id);
                 self.slice(fields, |field| {
                     self.ident(field!(field.ident));
                     self.pat(field!(field.pat));
@@ -771,7 +772,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
             PatKind::TupleStruct(ref qpath, fields, skip_pos) => {
                 bind!(self, qpath, fields);
                 kind!("TupleStruct(ref {qpath}, {fields}, {skip_pos:?})");
-                self.qpath(qpath, pat);
+                self.qpath(qpath, &pat.name, pat.value.hir_id);
                 self.slice(fields, |pat| self.pat(pat));
             },
             PatKind::Tuple(fields, skip_pos) => {
diff --git a/clippy_lints_internal/src/unnecessary_def_path.rs b/clippy_lints_internal/src/unnecessary_def_path.rs
index 8877f1faf0ee..ceb622d33dbd 100644
--- a/clippy_lints_internal/src/unnecessary_def_path.rs
+++ b/clippy_lints_internal/src/unnecessary_def_path.rs
@@ -1,7 +1,8 @@
 use crate::internal_paths;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::paths::{PathNS, lookup_path};
-use clippy_utils::{path_def_id, peel_ref_operators};
+use clippy_utils::peel_ref_operators;
+use clippy_utils::res::PathRes;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -53,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryDefPath {
             let path: Vec<Symbol> = segments
                 .iter()
                 .map(|segment| {
-                    if let Some(const_def_id) = path_def_id(cx, segment)
+                    if let Some(const_def_id) = cx.path_def_id(segment)
                         && let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(const_def_id)
                         && let Some(value) = value.to_u32().discard_err()
                     {
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 0bb19dab1f7a..27f9c150c5bd 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -65,6 +65,7 @@ pub mod numeric_literal;
 pub mod paths;
 pub mod ptr;
 pub mod qualify_min_const_fn;
+pub mod res;
 pub mod source;
 pub mod str_utils;
 pub mod sugg;
@@ -129,6 +130,7 @@ use visitors::{Visitable, for_each_unconsumed_temporary};
 use crate::ast_utils::unordered_over;
 use crate::consts::{ConstEvalCtxt, Constant, mir_to_const};
 use crate::higher::Range;
+use crate::res::PathRes;
 use crate::ty::{adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type};
 use crate::visitors::for_each_expr_without_closures;
 
@@ -250,10 +252,10 @@ pub fn is_inside_always_const_context(tcx: TyCtxt<'_>, hir_id: HirId) -> bool {
 
 /// Checks if a `Res` refers to a constructor of a `LangItem`
 /// For example, use this to check whether a function call or a pattern is `Some(..)`.
-pub fn is_res_lang_ctor(cx: &LateContext<'_>, res: Res, lang_item: LangItem) -> bool {
+pub fn is_res_lang_ctor(tcx: TyCtxt<'_>, res: Res, lang_item: LangItem) -> bool {
     if let Res::Def(DefKind::Ctor(..), id) = res
-        && let Some(lang_id) = cx.tcx.lang_items().get(lang_item)
-        && let Some(id) = cx.tcx.opt_parent(id)
+        && let Some(lang_id) = tcx.lang_items().get(lang_item)
+        && let Some(id) = tcx.opt_parent(id)
     {
         id == lang_id
     } else {
@@ -331,11 +333,7 @@ pub fn is_wild(pat: &Pat<'_>) -> bool {
 
 // Checks if arm has the form `None => None`
 pub fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-    matches!(
-        arm.pat.kind,
-        PatKind::Expr(PatExpr { kind: PatExprKind::Path(qpath), .. })
-            if is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), OptionNone)
-    )
+    cx.is_path_lang_ctor(arm.pat, OptionNone)
 }
 
 /// Checks if the given `QPath` belongs to a type alias.
@@ -430,22 +428,6 @@ pub fn qpath_generic_tys<'tcx>(qpath: &QPath<'tcx>) -> impl Iterator<Item = &'tc
         })
 }
 
-/// If `maybe_path` is a path node which resolves to an item, resolves it to a `DefId` and checks if
-/// it matches the given lang item.
-pub fn is_path_lang_item<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>, lang_item: LangItem) -> bool {
-    path_def_id(cx, maybe_path).is_some_and(|id| cx.tcx.lang_items().get(lang_item) == Some(id))
-}
-
-/// If `maybe_path` is a path node which resolves to an item, resolves it to a `DefId` and checks if
-/// it matches the given diagnostic item.
-pub fn is_path_diagnostic_item<'tcx>(
-    cx: &LateContext<'_>,
-    maybe_path: &impl MaybePath<'tcx>,
-    diag_item: Symbol,
-) -> bool {
-    path_def_id(cx, maybe_path).is_some_and(|id| cx.tcx.is_diagnostic_item(diag_item, id))
-}
-
 /// If the expression is a path to a local, returns the canonical `HirId` of the local.
 pub fn path_to_local(expr: &Expr<'_>) -> Option<HirId> {
     if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind
@@ -479,56 +461,6 @@ pub fn path_to_local_with_projections(expr: &Expr<'_>) -> Option<HirId> {
     }
 }
 
-pub trait MaybePath<'hir> {
-    fn hir_id(&self) -> HirId;
-    fn qpath_opt(&self) -> Option<&QPath<'hir>>;
-}
-
-macro_rules! maybe_path {
-    ($ty:ident, $kind:ident) => {
-        impl<'hir> MaybePath<'hir> for hir::$ty<'hir> {
-            fn hir_id(&self) -> HirId {
-                self.hir_id
-            }
-            fn qpath_opt(&self) -> Option<&QPath<'hir>> {
-                match &self.kind {
-                    hir::$kind::Path(qpath) => Some(qpath),
-                    _ => None,
-                }
-            }
-        }
-    };
-}
-maybe_path!(Expr, ExprKind);
-impl<'hir> MaybePath<'hir> for Pat<'hir> {
-    fn hir_id(&self) -> HirId {
-        self.hir_id
-    }
-    fn qpath_opt(&self) -> Option<&QPath<'hir>> {
-        match &self.kind {
-            PatKind::Expr(PatExpr {
-                kind: PatExprKind::Path(qpath),
-                ..
-            }) => Some(qpath),
-            _ => None,
-        }
-    }
-}
-maybe_path!(Ty, TyKind);
-
-/// If `maybe_path` is a path node, resolves it, otherwise returns `Res::Err`
-pub fn path_res<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>) -> Res {
-    match maybe_path.qpath_opt() {
-        None => Res::Err,
-        Some(qpath) => cx.qpath_res(qpath, maybe_path.hir_id()),
-    }
-}
-
-/// If `maybe_path` is a path node which resolves to an item, retrieves the item ID
-pub fn path_def_id<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>) -> Option<DefId> {
-    path_res(cx, maybe_path).opt_def_id()
-}
-
 /// Gets the `hir::TraitRef` of the trait the given method is implemented for.
 ///
 /// Use this if you want to find the `TraitRef` of the `Add` trait in this example:
@@ -766,7 +698,7 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
         },
         ExprKind::Call(repl_func, []) => is_default_equivalent_call(cx, repl_func, Some(e)),
         ExprKind::Call(from_func, [arg]) => is_default_equivalent_from(cx, from_func, arg),
-        ExprKind::Path(qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, e.hir_id), OptionNone),
+        ExprKind::Path(qpath) => cx.is_path_lang_ctor((qpath, e.hir_id), OptionNone),
         ExprKind::AddrOf(rustc_hir::BorrowKind::Ref, _, expr) => matches!(expr.kind, ExprKind::Array([])),
         ExprKind::Block(Block { stmts: [], expr, .. }, _) => expr.is_some_and(|e| is_default_equivalent(cx, e)),
         _ => false,
@@ -776,19 +708,21 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
 fn is_default_equivalent_from(cx: &LateContext<'_>, from_func: &Expr<'_>, arg: &Expr<'_>) -> bool {
     if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = from_func.kind
         && seg.ident.name == sym::from
+        && let TyKind::Path(QPath::Resolved(_, ty_path)) = ty.kind
+        && let Res::Def(DefKind::Struct, ty_did) = ty_path.res
     {
         match arg.kind {
             ExprKind::Lit(hir::Lit {
                 node: LitKind::Str(sym, _),
                 ..
-            }) => return sym.is_empty() && is_path_lang_item(cx, ty, LangItem::String),
-            ExprKind::Array([]) => return is_path_diagnostic_item(cx, ty, sym::Vec),
+            }) => return sym.is_empty() && cx.tcx.lang_items().string() == Some(ty_did),
+            ExprKind::Array([]) => return cx.tcx.is_diagnostic_item(sym::Vec, ty_did),
             ExprKind::Repeat(_, len) => {
                 if let ConstArgKind::Anon(anon_const) = len.kind
                     && let ExprKind::Lit(const_lit) = cx.tcx.hir_body(anon_const.body).value.kind
                     && let LitKind::Int(v, _) = const_lit.node
                 {
-                    return v == 0 && is_path_diagnostic_item(cx, ty, sym::Vec);
+                    return v == 0 && cx.tcx.is_diagnostic_item(sym::Vec, ty_did);
                 }
             },
             _ => (),
@@ -1671,7 +1605,7 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
     fn is_ok(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
         if let PatKind::TupleStruct(ref path, pat, ddpos) = arm.pat.kind
             && ddpos.as_opt_usize().is_none()
-            && is_res_lang_ctor(cx, cx.qpath_res(path, arm.pat.hir_id), ResultOk)
+            && cx.is_path_lang_ctor((path, arm.pat.hir_id), ResultOk)
             && let PatKind::Binding(_, hir_id, _, None) = pat[0].kind
             && path_to_local_id(arm.body, hir_id)
         {
@@ -1682,7 +1616,7 @@ pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tc
 
     fn is_err(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
         if let PatKind::TupleStruct(ref path, _, _) = arm.pat.kind {
-            is_res_lang_ctor(cx, cx.qpath_res(path, arm.pat.hir_id), ResultErr)
+            cx.is_path_lang_ctor((path, arm.pat.hir_id), ResultErr)
         } else {
             false
         }
@@ -2058,7 +1992,8 @@ pub fn is_expr_untyped_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>)
 pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     match expr.kind {
         ExprKind::Closure(&Closure { body, .. }) => is_body_identity_function(cx, cx.tcx.hir_body(body)),
-        _ => path_def_id(cx, expr).is_some_and(|id| cx.tcx.is_diagnostic_item(sym::convert_identity, id)),
+        ExprKind::Path(ref qpath) => cx.is_path_diag_item((qpath, expr.hir_id), sym::convert_identity),
+        _ => false,
     }
 }
 
@@ -2934,13 +2869,12 @@ pub fn pat_and_expr_can_be_question_mark<'a, 'hir>(
     pat: &'a Pat<'hir>,
     else_body: &Expr<'_>,
 ) -> Option<&'a Pat<'hir>> {
-    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind
-        && is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome)
+    if let PatKind::TupleStruct(ref pat_path, [inner_pat], _) = pat.kind
+        && cx.is_path_lang_ctor((pat_path, pat.hir_id), OptionSome)
         && !is_refutable(cx, inner_pat)
         && let else_body = peel_blocks(else_body)
         && let ExprKind::Ret(Some(ret_val)) = else_body.kind
-        && let ExprKind::Path(ret_path) = ret_val.kind
-        && is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
+        && cx.is_path_lang_ctor(ret_val, OptionNone)
     {
         Some(inner_pat)
     } else {
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index ea8cfc59356a..9b923759b3c2 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -4,7 +4,8 @@
 //! Whenever possible, please consider diagnostic items over hardcoded paths.
 //! See <https://github.com/rust-lang/rust-clippy/issues/5393> for more information.
 
-use crate::{MaybePath, path_def_id, sym};
+use crate::res::{MaybeQPath, PathRes};
+use crate::sym;
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::Namespace::{MacroNS, TypeNS, ValueNS};
@@ -95,8 +96,9 @@ impl PathLookup {
     }
 
     /// Resolves `maybe_path` to a [`DefId`] and checks if the [`PathLookup`] matches it
-    pub fn matches_path<'tcx>(&self, cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>) -> bool {
-        path_def_id(cx, maybe_path).is_some_and(|def_id| self.matches(cx, def_id))
+    pub fn matches_path<'a>(&self, cx: &LateContext<'_>, maybe_path: impl MaybeQPath<'a>) -> bool {
+        cx.path_def_id(maybe_path)
+            .is_some_and(|def_id| self.matches(cx, def_id))
     }
 
     /// Checks if the path resolves to `ty`'s definition, must be an `Adt`
diff --git a/clippy_utils/src/res.rs b/clippy_utils/src/res.rs
new file mode 100644
index 000000000000..9e66a0c21945
--- /dev/null
+++ b/clippy_utils/src/res.rs
@@ -0,0 +1,233 @@
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
+use rustc_hir::{Expr, ExprKind, HirId, LangItem, Pat, PatExpr, PatExprKind, PatKind, QPath, Ty, TyKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::TypeckResults;
+use rustc_middle::ty::layout::HasTyCtxt;
+use rustc_span::Symbol;
+
+/// A `QPath` with the `HirId` of the node containing it.
+type QPathId<'tcx> = (&'tcx QPath<'tcx>, HirId);
+
+/// A HIR node which might be a `QPath`.
+pub trait MaybeQPath<'tcx> {
+    /// If this node is a path gets both the contained path and the `HirId` to
+    /// use for type dependant lookup.
+    fn opt_qpath(self) -> Option<QPathId<'tcx>>;
+}
+
+impl<'tcx> MaybeQPath<'tcx> for QPathId<'tcx> {
+    #[inline]
+    fn opt_qpath(self) -> Option<QPathId<'tcx>> {
+        Some((self.0, self.1))
+    }
+}
+impl<'tcx> MaybeQPath<'tcx> for &'tcx Expr<'_> {
+    #[inline]
+    fn opt_qpath(self) -> Option<QPathId<'tcx>> {
+        match &self.kind {
+            ExprKind::Path(qpath) => Some((qpath, self.hir_id)),
+            _ => None,
+        }
+    }
+}
+impl<'tcx> MaybeQPath<'tcx> for &'tcx PatExpr<'_> {
+    #[inline]
+    fn opt_qpath(self) -> Option<QPathId<'tcx>> {
+        match &self.kind {
+            PatExprKind::Path(qpath) => Some((qpath, self.hir_id)),
+            _ => None,
+        }
+    }
+}
+impl<'tcx, AmbigArg> MaybeQPath<'tcx> for &'tcx Ty<'_, AmbigArg> {
+    #[inline]
+    fn opt_qpath(self) -> Option<QPathId<'tcx>> {
+        match &self.kind {
+            TyKind::Path(qpath) => Some((qpath, self.hir_id)),
+            _ => None,
+        }
+    }
+}
+impl<'tcx> MaybeQPath<'tcx> for &'_ Pat<'tcx> {
+    #[inline]
+    fn opt_qpath(self) -> Option<QPathId<'tcx>> {
+        match self.kind {
+            PatKind::Expr(e) => e.opt_qpath(),
+            _ => None,
+        }
+    }
+}
+impl<'tcx, T: MaybeQPath<'tcx>> MaybeQPath<'tcx> for Option<T> {
+    #[inline]
+    fn opt_qpath(self) -> Option<QPathId<'tcx>> {
+        self.and_then(T::opt_qpath)
+    }
+}
+impl<'tcx, T: Copy + MaybeQPath<'tcx>> MaybeQPath<'tcx> for &'_ T {
+    #[inline]
+    fn opt_qpath(self) -> Option<QPathId<'tcx>> {
+        T::opt_qpath(*self)
+    }
+}
+
+/// A type which contains the results of type dependant name resolution.
+///
+/// All the functions on this trait will lookup the path's resolution. This lookup
+/// is not free and should be done at most once per item. e.g.
+///
+/// ```ignore
+/// // Don't do this
+/// let is_option_ctor = item.is_path_lang_item(tcx, LangItem::OptionSome)
+///     || item.is_path_lang_item(tcx, LangItem::OptionNone);
+///
+/// // Prefer this
+/// let is_option_ctor = item.path_def_id().is_some_and(|did| {
+///     tcx.lang_items().option_none_variant() == Some(did)
+///         || tcx.lang_items().option_some_variant() == Some(did)
+/// });
+/// ```
+pub trait PathRes<'tcx> {
+    /// Gets the definition a node resolves to if it has a type dependent resolution.
+    fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)>;
+
+    /// Gets the resolution of a node if it has a type dependent resolution. Returns
+    /// `Res::Err` otherwise.
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn type_dependent_res(&self, id: HirId) -> Res {
+        self.type_dependent_def(id)
+            .map_or(Res::Err, |(kind, id)| Res::Def(kind, id))
+    }
+
+    /// Gets the resolution of the path.
+    ///
+    /// `id` must be the `HirId` of the node containing `qpath`.
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn qpath_res(&self, qpath: &QPath<'_>, id: HirId) -> Res {
+        match qpath {
+            QPath::Resolved(_, p) => p.res,
+            QPath::TypeRelative(..) | QPath::LangItem(..) => self.type_dependent_res(id),
+        }
+    }
+
+    /// Gets the resolution of the item if it's a path. Returns `Res::Err` otherwise.
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn path_res<'a>(&self, path: impl MaybeQPath<'a>) -> Res {
+        match path.opt_qpath() {
+            Some((qpath, hir_id)) => self.qpath_res(qpath, hir_id),
+            None => Res::Err,
+        }
+    }
+
+    /// Gets the definition the given node resolves to.
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn path_def<'a>(&self, path: impl MaybeQPath<'a>) -> Option<(DefKind, DefId)> {
+        match path.opt_qpath() {
+            Some((&QPath::Resolved(_, p), _)) => match p.res {
+                Res::Def(kind, id) => Some((kind, id)),
+                _ => None,
+            },
+            Some((QPath::TypeRelative(..) | QPath::LangItem(..), id)) => self.type_dependent_def(id),
+            _ => None,
+        }
+    }
+
+    /// Gets the `DefId` of the item the given node resolves to.
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn path_def_id<'a>(&self, path: impl MaybeQPath<'a>) -> Option<DefId> {
+        self.path_def(path).map(|(_, id)| id)
+    }
+
+    /// Checks if the path resolves to the specified item.
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn is_path_item<'a>(&self, path: impl MaybeQPath<'a>, did: DefId) -> bool {
+        self.path_def_id(path) == Some(did)
+    }
+
+    /// Gets the diagnostic name of the item the given node resolves to.
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn path_diag_name<'a>(&self, path: impl MaybeQPath<'a>) -> Option<Symbol>
+    where
+        Self: HasTyCtxt<'tcx>,
+    {
+        self.path_def_id(path)
+            .and_then(|did| self.tcx().get_diagnostic_name(did))
+    }
+
+    /// Checks if the path resolves to the specified diagnostic item.
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn is_path_diag_item<'a>(&self, path: impl MaybeQPath<'a>, name: Symbol) -> bool
+    where
+        Self: HasTyCtxt<'tcx>,
+    {
+        self.path_def_id(path)
+            .is_some_and(|did| self.tcx().is_diagnostic_item(name, did))
+    }
+
+    /// Checks if the path resolves to the specified `LangItem`.
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn is_path_lang_item<'a>(&self, path: impl MaybeQPath<'a>, item: LangItem) -> bool
+    where
+        Self: HasTyCtxt<'tcx>,
+    {
+        self.path_def_id(path)
+            .is_some_and(|did| self.tcx().lang_items().get(item) == Some(did))
+    }
+
+    /// If the path resolves to a constructor, gets the `DefId` of the corresponding struct/variant.
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn path_ctor_parent_id<'a>(&self, path: impl MaybeQPath<'a>) -> Option<DefId>
+    where
+        Self: HasTyCtxt<'tcx>,
+    {
+        if let Res::Def(DefKind::Ctor(..), id) = self.path_res(path) {
+            self.tcx().opt_parent(id)
+        } else {
+            None
+        }
+    }
+
+    /// Checks if the path resolves to the constructor of the specified `LangItem`.
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn is_path_lang_ctor<'a>(&self, path: impl MaybeQPath<'a>, item: LangItem) -> bool
+    where
+        Self: HasTyCtxt<'tcx>,
+    {
+        self.path_ctor_parent_id(path)
+            .is_some_and(|did| self.tcx().lang_items().get(item) == Some(did))
+    }
+}
+impl<'tcx> PathRes<'tcx> for LateContext<'tcx> {
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> {
+        if let Some(typeck) = self.maybe_typeck_results() {
+            PathRes::type_dependent_def(typeck, id)
+        } else {
+            // It's possible to get the `TypeckResults` for any other body, but
+            // attempting to lookup the type of something across bodies like this
+            // is a good indication of a bug.
+            debug_assert!(false, "attempted type-dependent lookup in a non-body context");
+            None
+        }
+    }
+}
+impl PathRes<'_> for TypeckResults<'_> {
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> {
+        if id.owner == self.hir_owner {
+            self.type_dependent_def(id)
+        } else {
+            debug_assert!(
+                false,
+                "attempted type-dependent lookup for a node in the wrong body.\n  in body `{:?}`\n  expected body `{:?}`",
+                self.hir_owner, id.owner,
+            );
+            None
+        }
+    }
+}
diff --git a/clippy_utils/src/ty/mod.rs b/clippy_utils/src/ty/mod.rs
index 8e302f9d2ad1..64dfe7143ac2 100644
--- a/clippy_utils/src/ty/mod.rs
+++ b/clippy_utils/src/ty/mod.rs
@@ -34,8 +34,8 @@ use std::assert_matches::debug_assert_matches;
 use std::collections::hash_map::Entry;
 use std::{iter, mem};
 
-use crate::path_res;
 use crate::paths::{PathNS, lookup_path_str};
+use crate::res::PathRes;
 
 mod type_certainty;
 pub use type_certainty::expr_type_is_certain;
@@ -646,7 +646,7 @@ impl<'tcx> ExprFnSig<'tcx> {
 
 /// If the expression is function like, get the signature for it.
 pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnSig<'tcx>> {
-    if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = path_res(cx, expr) {
+    if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = cx.path_res(expr) {
         Some(ExprFnSig::Sig(cx.tcx.fn_sig(id).instantiate_identity(), Some(id)))
     } else {
         ty_sig(cx, cx.typeck_results().expr_ty_adjusted(expr).peel_refs())
diff --git a/tests/ui/author/blocks.stdout b/tests/ui/author/blocks.stdout
index e453299edbcf..2e4a238b85ee 100644
--- a/tests/ui/author/blocks.stdout
+++ b/tests/ui/author/blocks.stdout
@@ -23,13 +23,13 @@ if let ExprKind::Block(block, None) = expr.kind
     && let StmtKind::Let(local) = block.stmts[0].kind
     && let Some(init) = local.init
     && let ExprKind::Call(func, args) = init.kind
-    && is_path_diagnostic_item(cx, func, sym::string_new)
+    && cx.is_path_diag_item(func, sym::string_new)
     && args.is_empty()
     && let PatKind::Binding(BindingMode::NONE, _, name, None) = local.pat.kind
     && name.as_str() == "expr"
     && let Some(trailing_expr) = block.expr
     && let ExprKind::Call(func1, args1) = trailing_expr.kind
-    && is_path_diagnostic_item(cx, func1, sym::mem_drop)
+    && cx.is_path_diag_item(func1, sym::mem_drop)
     && args1.len() == 1
 {
     // report your lint here
diff --git a/tests/ui/author/call.stdout b/tests/ui/author/call.stdout
index 2b179d45112e..db00f2b404b2 100644
--- a/tests/ui/author/call.stdout
+++ b/tests/ui/author/call.stdout
@@ -1,7 +1,7 @@
 if let StmtKind::Let(local) = stmt.kind
     && let Some(init) = local.init
     && let ExprKind::Call(func, args) = init.kind
-    && is_path_diagnostic_item(cx, func, sym::cmp_min)
+    && cx.is_path_diag_item(func, sym::cmp_min)
     && args.len() == 2
     && let ExprKind::Lit(ref lit) = args[0].kind
     && let LitKind::Int(3, LitIntType::Unsuffixed) = lit.node
diff --git a/tests/ui/author/issue_3849.stdout b/tests/ui/author/issue_3849.stdout
index f02ea5bf075f..dd0d51c45232 100644
--- a/tests/ui/author/issue_3849.stdout
+++ b/tests/ui/author/issue_3849.stdout
@@ -1,7 +1,7 @@
 if let StmtKind::Let(local) = stmt.kind
     && let Some(init) = local.init
     && let ExprKind::Call(func, args) = init.kind
-    && is_path_diagnostic_item(cx, func, sym::transmute)
+    && cx.is_path_diag_item(func, sym::transmute)
     && args.len() == 1
     && let PatKind::Wild = local.pat.kind
 {