Add extra check to format_impl lint for self.fmt()

As mentioned in this Reddit comment:
https://www.reddit.com/r/rust/comments/tq602q/my_first_clippy_lint_detecting_use_of_self_as/i2fhdy1/

Previously use of self.fmt within the Format trait wasn't detected

Note we don't check fully qualified paths atm, but that shouldn't happen
by accident anyway.

Author: jamesmcm

clippy_lints/src/format_impl.rs

@@ -131,11 +131,38 @@ impl<'tcx> LateLintPass<'tcx> for FormatImpl {
             check_to_string_in_display(cx, expr);
         }
 
+        check_self_fmt_in_fmt(cx, expr, format_trait_impl);
         check_self_in_format_args(cx, expr, format_trait_impl);
         check_print_in_format_impl(cx, expr, format_trait_impl);
     }
 }
 
+fn check_self_fmt_in_fmt(cx: &LateContext<'_>, expr: &Expr<'_>, format_trait: FormatTrait) {
+    if_chain! {
+        // Get the hir_id of the object we are calling the method on
+        if let ExprKind::MethodCall(path, [ref self_arg, ..], _) = expr.kind;
+        // Is the method to_string() ?
+        if path.ident.name == sym!(fmt);
+        // Is the method a part of the ToString trait? (i.e. not to_string() implemented
+        // separately)
+        if let FormatTrait { name, .. } = format_trait;
+        if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+        if is_diag_trait_item(cx, expr_def_id, name);
+        // Is the method is called on self
+        if let ExprKind::Path(QPath::Resolved(_, path)) = self_arg.kind;
+        if let [segment] = path.segments;
+        if segment.ident.name == kw::SelfLower;
+        then {
+            span_lint(
+                cx,
+                RECURSIVE_FORMAT_IMPL,
+                expr.span,
+                &format!("using `self.fmt` as `{name}` in `impl {name}` will cause infinite recursion"),
+            );
+        }
+    }
+}
+
 fn check_to_string_in_display(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
         // Get the hir_id of the object we are calling the method on

tests/ui/recursive_format_impl.rs

@@ -310,6 +310,43 @@ impl std::fmt::Debug for Tree {
     }
 }
 
+// Should also catch use of self.fmt within the Format trait
+
+enum Foo {
+    Foo(usize),
+    Bar(usize),
+}
+
+impl std::fmt::Display for Foo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Foo(_) => self.fmt(f),
+            Self::Bar(x) => x.fmt(f),
+        }
+    }
+}
+
+// Doesn't trigger on nested enum matching
+enum Tree2 {
+    Leaf,
+    Node(Vec<Tree>),
+}
+
+impl std::fmt::Display for Tree2 {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Tree2::Leaf => write!(f, "*"),
+            Tree2::Node(children) => {
+                write!(f, "(")?;
+                for child in children.iter() {
+                    child.fmt(f)?;
+                }
+                write!(f, ")")
+            },
+        }
+    }
+}
+
 fn main() {
     let a = A;
     a.to_string();

tests/ui/recursive_format_impl.stderr

@@ -87,5 +87,11 @@ LL |         write!(f, "{}", &&**&&*self)
    |
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 11 previous errors
+error: using `self.fmt` as `Display` in `impl Display` will cause infinite recursion
+  --> $DIR/recursive_format_impl.rs:323:29
+   |
+LL |             Self::Foo(_) => self.fmt(f),
+   |                             ^^^^^^^^^^^
+
+error: aborting due to 12 previous errors