add a helper for extracting fn def id and node args together

Author: y21

clippy_lints/src/unconditional_recursion.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{expr_or_init, fn_def_id, get_trait_def_id, path_def_id};
+use clippy_utils::{expr_or_init, fn_def_id_with_node_args, get_trait_def_id, path_def_id};
 use itertools::Itertools;
 use rustc_ast::BinOpKind;
 use rustc_data_structures::fx::FxHashMap;
@@ -401,20 +401,14 @@ fn check_from(cx: &LateContext<'_>, method_span: Span, method_def_id: LocalDefId
     else {
         return;
     };
-    let typeck = cx.typeck_results();
 
     // Check if we are calling `Into::into` where the node args match with our `From::from` signature:
     // From::from signature: fn(S1) -> S2
     // <S1 as Into<S2>>::into(s1), node_args=[S1, S2]
     // If they do match, then it must mean that it is the blanket impl,
     // which calls back into our `From::from` again (`Into` is not specializable).
     // rustc's unconditional_recursion already catches calling `From::from` directly
-    if let Some(fn_def_id) = fn_def_id(cx, expr)
-        && let node_args = match expr.kind {
-            ExprKind::MethodCall(..) => typeck.node_args(expr.hir_id),
-            ExprKind::Call(callee, _) => typeck.node_args(callee.hir_id),
-            _ => return,
-        }
+    if let Some((fn_def_id, node_args)) = fn_def_id_with_node_args(cx, expr)
         && let Some((s1, s2)) = node_args.iter().filter_map(ty::GenericArg::as_type).collect_tuple()
         && let Some(trait_def_id) = cx.tcx.trait_of_item(fn_def_id)
         && cx.tcx.is_diagnostic_item(sym::Into, trait_def_id)

clippy_utils/src/lib.rs

@@ -2249,8 +2249,21 @@ pub fn fn_has_unsatisfiable_preds(cx: &LateContext<'_>, did: DefId) -> bool {
 
 /// Returns the `DefId` of the callee if the given expression is a function or method call.
 pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
+    fn_def_id_with_node_args(cx, expr).map(|(did, _)| did)
+}
+
+/// Returns the `DefId` of the callee if the given expression is a function or method call,
+/// as well as its node args.
+pub fn fn_def_id_with_node_args<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &Expr<'_>,
+) -> Option<(DefId, rustc_ty::GenericArgsRef<'tcx>)> {
+    let typeck = cx.typeck_results();
     match &expr.kind {
-        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
+        ExprKind::MethodCall(..) => Some((
+            typeck.type_dependent_def_id(expr.hir_id)?,
+            typeck.node_args(expr.hir_id),
+        )),
         ExprKind::Call(
             Expr {
                 kind: ExprKind::Path(qpath),
@@ -2262,9 +2275,9 @@ pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
             // Only return Fn-like DefIds, not the DefIds of statics/consts/etc that contain or
             // deref to fn pointers, dyn Fn, impl Fn - #8850
             if let Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, id) =
-                cx.typeck_results().qpath_res(qpath, *path_hir_id)
+                typeck.qpath_res(qpath, *path_hir_id)
             {
-                Some(id)
+                Some((id, typeck.node_args(*path_hir_id)))
             } else {
                 None
             }

tests/ui/unconditional_recursion.rs

@@ -363,7 +363,7 @@ impl<'a> From<BadFromTy1<'a>> for BadIntoTy1<'static> {
     }
 }
 
-// From::from -> From::from
+// Using UFCS syntax
 struct BadFromTy2<'a>(&'a ());
 struct BadIntoTy2<'b>(&'b ());
 impl<'a> From<BadFromTy2<'a>> for BadIntoTy2<'static> {