Restrict lint to Debug types

This avoids having the lint show upon usage of `.err().expect()` on types that do not implement Debug

Author: b-NC

clippy_lints/src/methods/err_expect.rs

@@ -1,18 +1,44 @@
 use super::ERR_EXPECT;
 use clippy_utils::{diagnostics::span_lint_and_help, meets_msrv, msrvs, ty::is_type_diagnostic_item};
+use clippy_utils::ty::implements_trait;
 use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_middle::ty::Ty;
 use rustc_semver::RustcVersion;
 use rustc_span::sym;
 
 pub(super) fn check(cx: &LateContext<'_>, expr: &rustc_hir::Expr<'_>, recv: &rustc_hir::Expr<'_>, msrv: Option<&RustcVersion>) {
-    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result) & meets_msrv(msrv, &msrvs::EXPECT_ERR) {
-        span_lint_and_help(
+    if_chain! {
+        if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
+        if meets_msrv(msrv, &msrvs::EXPECT_ERR);
+
+        let result_type = cx.typeck_results().expr_ty(recv);
+        if let Some(error_type) = get_error_type(cx, result_type);
+        if has_debug_impl(error_type, cx);
+
+        then {
+                    span_lint_and_help(
             cx,
             ERR_EXPECT,
             expr.span,
             "called `.err().expect()` on a `Result` value",
             None,
             "`.expect_err()` can be called instead",
         );
+        }
     }
 }
+
+/// Given a `Result<T, E>` type, return its error type (`E`).
+fn get_error_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {
+    match ty.kind() {
+        ty::Adt(_, substs) if is_type_diagnostic_item(cx, ty, sym::Result) => substs.types().nth(1),
+        _ => None,
+    }
+}
+
+fn has_debug_impl<'tcx>(ty: Ty<'tcx>, cx: &LateContext<'tcx>) -> bool {
+    cx.tcx
+        .get_diagnostic_item(sym::Debug)
+        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
+}

tests/ui/err_expect.rs

@@ -1,4 +1,12 @@
+struct MyTypeNonDebug;
+
+#[derive(Debug)]
+struct MyTypeDebug;
+
 fn main() {
-    let x: Result<u32, &str> = Ok(10);
-    x.err().expect("Testing expect_err");
+    let test_debug: Result<u32, MyTypeDebug> = Ok(0);
+    test_debug.err().expect("Testing debug type");
+
+    let test_non_debug: Result<u32, MyTypeNonDebug> = Ok(0);
+    test_non_debug.err().expect("Testing non debug type");
 }