Remove path_res

Author: Jarcho

clippy_lints/src/assertions_on_result_states.rs

@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{PanicExpn, find_assert_args, root_macro_call_first_node};
-use clippy_utils::res::MaybeDef;
+use clippy_utils::res::{MaybeDef, MaybeResPath};
 use clippy_utils::source::snippet_with_context;
+use clippy_utils::sym;
 use clippy_utils::ty::{has_debug_impl, is_copy};
 use clippy_utils::usage::local_used_after_expr;
-use clippy_utils::{path_res, sym};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind, Node};
@@ -62,7 +62,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 Res::Local(binding_id) = *recv.basic_res()
                     && local_used_after_expr(cx, binding_id, recv)
                 {
                     return;

clippy_lints/src/derive/mod.rs

@@ -1,4 +1,4 @@
-use clippy_utils::path_res;
+use clippy_utils::res::MaybeResPath;
 use rustc_hir::def::Res;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -199,7 +199,7 @@ impl<'tcx> LateLintPass<'tcx> for Derive {
             self_ty,
             ..
         }) = item.kind
-            && let Res::Def(_, def_id) = path_res(cx, self_ty)
+            && let Res::Def(_, def_id) = *self_ty.basic_res()
             && let Some(local_def_id) = def_id.as_local()
         {
             let adt_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id);

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::MaybeResPath;
 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) = imp.self_ty.basic_res().opt_def_id().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) =>

clippy_lints/src/if_then_some_else_none.rs

@@ -2,11 +2,12 @@ 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::MaybeQPath;
 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,
+    peel_blocks, sym,
 };
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
@@ -73,8 +74,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)
+            && is_res_lang_ctor(cx, then_call.res(cx), OptionSome)
+            && is_res_lang_ctor(cx, peel_blocks(els).res(cx), OptionNone)
             && !is_else_clause(cx.tcx, expr)
             && !is_in_const_context(cx)
             && self.msrv.meets(cx, msrvs::BOOL_THEN)

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::{MaybeQPath, MaybeResPath};
 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, is_res_lang_ctor, 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)
+        && is_res_lang_ctor(cx, ctor.res(cx), LangItem::OptionSome)
+        && inner_ret.res_local_id() == Some(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)
+        && is_res_lang_ctor(cx, last_ret.res(cx), LangItem::OptionNone)
         && let Some((_, Node::Expr(_block))) = parent_iter.next()
         // This includes the function header
         && let Some((_, func)) = parent_iter.next()

clippy_lints/src/manual_clamp.rs

@@ -3,11 +3,12 @@ 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::MaybeResPath;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::is_const_evaluatable;
 use clippy_utils::{
-    eq_expr_value, is_diag_trait_item, is_in_const_context, is_trait_method, path_res, path_to_local_id, peel_blocks,
+    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;
@@ -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!(ty.basic_res(), Res::PrimTy(PrimTy::Float(_))).then(|| FunctionType::OrdOrFloat(seg))
             },
             _ => None,
         }

clippy_lints/src/matches/manual_filter.rs

@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::res::MaybeDef;
+use clippy_utils::res::{MaybeDef, MaybeQPath};
 use clippy_utils::visitors::contains_unsafe_block;
-use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
+use clippy_utils::{is_res_lang_ctor, path_to_local_id};
 
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatKind};
@@ -66,15 +66,15 @@ fn is_some_expr(cx: &LateContext<'_>, target: HirId, ctxt: SyntaxContext, expr:
         && let ExprKind::Call(callee, [arg]) = inner_expr.kind
     {
         return ctxt == expr.span.ctxt()
-            && is_res_lang_ctor(cx, path_res(cx, callee), OptionSome)
+            && is_res_lang_ctor(cx, callee.res(cx), 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 is_res_lang_ctor(cx, inner_expr.res(cx), OptionNone);
     }
     false
 }

clippy_lints/src/matches/manual_map.rs

@@ -2,8 +2,9 @@ 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::is_res_lang_ctor;
 
+use clippy_utils::res::MaybeQPath;
 use rustc_hir::LangItem::OptionSome;
 use rustc_hir::{Arm, Block, BlockCheckMode, Expr, ExprKind, Pat, UnsafeSource};
 use rustc_lint::LateContext;
@@ -91,7 +92,7 @@ fn get_some_expr<'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) =>
+                if ctxt == expr.span.ctxt() && is_res_lang_ctor(cx, callee.res(cx), OptionSome) =>
             {
                 Some(SomeExpr::new_no_negated(arg, needs_unsafe_block))
             },

clippy_lints/src/matches/manual_ok_err.rs

@@ -1,8 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::res::MaybeQPath;
 use clippy_utils::source::{indent_of, reindent_multiline};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{option_arg_ty, peel_and_count_ty_refs};
-use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res, peel_blocks, span_contains_comment};
+use clippy_utils::{get_parent_expr, is_res_lang_ctor, peel_blocks, span_contains_comment};
 use rustc_ast::{BindingMode, Mutability};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr};
@@ -103,7 +104,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)
+        && is_res_lang_ctor(cx, body_callee.res(cx), OptionSome)
         && cx.typeck_results().expr_ty(body_arg) == ty
         && let ExprKind::Path(QPath::Resolved(
             _,
@@ -120,7 +121,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)
+    is_res_lang_ctor(cx, peel_blocks(expr).res(cx), OptionNone)
 }
 
 /// Suggest replacing `expr` by `scrutinee.METHOD()`, where `METHOD` is either `ok` or

clippy_lints/src/matches/manual_unwrap_or.rs

@@ -1,5 +1,5 @@
 use clippy_utils::consts::ConstEvalCtxt;
-use clippy_utils::res::MaybeDef;
+use clippy_utils::res::{MaybeDef, MaybeQPath};
 use clippy_utils::source::{SpanRangeExt as _, indent_of, reindent_multiline};
 use rustc_ast::{BindingMode, ByRef};
 use rustc_errors::Applicability;
@@ -12,7 +12,7 @@ use rustc_span::sym;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{expr_type_is_certain, 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};
 
@@ -115,7 +115,8 @@ 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)
+            if condition
+                .res(cx)
                 .opt_def_id()
                 .is_some_and(|id| Some(cx.tcx.parent(id)) == cx.tcx.lang_items().option_none_variant())
             {