unified type extraction

Author: J-ZhengLi

clippy_lints/src/question_mark.rs

@@ -10,6 +10,7 @@ use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
 use rustc_hir::{BindingAnnotation, Expr, ExprKind, PatKind, PathSegment, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, symbol::Symbol};
 
@@ -43,13 +44,21 @@ declare_lint_pass!(QuestionMark => [QUESTION_MARK]);
 enum IfBlockType<'hir> {
     /// An `if x.is_xxx() { a } else { b } ` expression.
     ///
-    /// Contains: caller (x), call_sym (is_xxx), if_then (a), if_else (b)
-    IfIs(&'hir Expr<'hir>, Symbol, &'hir Expr<'hir>, Option<&'hir Expr<'hir>>),
+    /// Contains: caller (x), caller_type, call_sym (is_xxx), if_then (a), if_else (b)
+    IfIs(
+        &'hir Expr<'hir>,
+        Ty<'hir>,
+        Symbol,
+        &'hir Expr<'hir>,
+        Option<&'hir Expr<'hir>>,
+    ),
     /// An `if let Xxx(a) = b { c } else { d }` expression.
     ///
-    /// Contains: let_pat_qpath (Xxx), let_pat_sym (a), let_expr (b), if_then (c), if_else (d)
+    /// Contains: let_pat_qpath (Xxx), let_pat_type, let_pat_sym (a), let_expr (b), if_then (c),
+    /// if_else (d)
     IfLet(
         &'hir QPath<'hir>,
+        Ty<'hir>,
         Symbol,
         &'hir Expr<'hir>,
         &'hir Expr<'hir>,
@@ -77,17 +86,18 @@ fn check_is_none_or_err_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>)
         if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr);
         if !is_else_clause(cx.tcx, expr);
         if let ExprKind::MethodCall(segment, args, _) = &cond.kind;
-        if let Some(subject) = args.get(0);
-        let if_block = IfBlockType::IfIs(subject, segment.ident.name, then, r#else);
+        if let Some(caller) = args.get(0);
+        let caller_ty = cx.typeck_results().expr_ty(caller);
+        let if_block = IfBlockType::IfIs(caller, caller_ty, segment.ident.name, then, r#else);
         if is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block);
         then {
             let mut applicability = Applicability::MachineApplicable;
-            let receiver_str = snippet_with_applicability(cx, subject.span, "..", &mut applicability);
-            let by_ref = move_by_default(cx, subject) &&
-                !matches!(subject.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
+            let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
+            let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx.at(caller.span), cx.param_env) &&
+                !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
             let mut suggestion = String::new();
             if let Some(else_inner) = r#else {
-                if eq_expr_value(cx, subject, peel_blocks(else_inner)) {
+                if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
                     suggestion = format!("Some({}?)", receiver_str);
                 }
             } else {
@@ -98,18 +108,14 @@ fn check_is_none_or_err_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>)
     }
 }
 
-fn move_by_default(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let expr_ty = cx.typeck_results().expr_ty(expr);
-    !expr_ty.is_copy_modulo_regions(cx.tcx.at(expr.span), cx.param_env)
-}
-
 fn check_if_let_some_or_err_and_early_return(cx: &LateContext<'_>, expr: &Expr<'_>) {
     if_chain! {
         if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else }) = higher::IfLet::hir(cx, expr);
         if !is_else_clause(cx.tcx, expr);
         if let PatKind::TupleStruct(ref path1, fields, None) = let_pat.kind;
         if let PatKind::Binding(annot, bind_id, ident, _) = fields[0].kind;
-        let if_block = IfBlockType::IfLet(path1, ident.name, let_expr, if_then, if_else);
+        let caller_ty = cx.typeck_results().expr_ty(let_expr);
+        let if_block = IfBlockType::IfLet(path1, caller_ty, ident.name, let_expr, if_then, if_else);
         if (is_early_return(sym::Option, cx, &if_block) && path_to_local_id(peel_blocks(if_then), bind_id))
             || is_early_return(sym::Result, cx, &if_block);
         then {
@@ -129,8 +135,7 @@ fn check_if_let_some_or_err_and_early_return(cx: &LateContext<'_>, expr: &Expr<'
 
 fn is_early_return(smbl: Symbol, cx: &LateContext<'_>, if_block: &IfBlockType<'_>) -> bool {
     match *if_block {
-        IfBlockType::IfIs(caller, call_sym, if_then, _) => {
-            let caller_ty = cx.typeck_results().expr_ty(caller);
+        IfBlockType::IfIs(caller, caller_ty, call_sym, if_then, _) => {
             // If the block could be identified as `if x.is_none()/is_err()`,
             // we then only need to check the if_then return to see if it is none/err.
             is_type_diagnostic_item(cx, caller_ty, smbl)
@@ -141,29 +146,24 @@ fn is_early_return(smbl: Symbol, cx: &LateContext<'_>, if_block: &IfBlockType<'_
                     _ => false,
                 }
         },
-        IfBlockType::IfLet(qpath, let_pat_sym, let_expr, if_then, if_else) => {
-            let let_expr_ty = cx.typeck_results().expr_ty(let_expr);
+        IfBlockType::IfLet(qpath, let_expr_ty, let_pat_sym, let_expr, if_then, if_else) => {
             is_type_diagnostic_item(cx, let_expr_ty, smbl)
                 && match smbl {
                     sym::Option => {
-                        // We only need to id `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
-                        let else_expr = if let Some(e) = if_else {
-                            e
-                        } else {
+                        // 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.
+                        if if_else.is_none() {
                             return false;
                         };
-                        expr_return_none_or_err(smbl, cx, else_expr, let_expr, None)
+                        expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, None)
                             && is_lang_ctor(cx, qpath, OptionSome)
                     },
                     sym::Result => {
                         if is_lang_ctor(cx, qpath, ResultOk) {
-                            let else_expr = if let Some(e) = if_else {
-                                e
-                            } else {
+                            if if_else.is_none() {
                                 return false;
                             };
-                            expr_return_none_or_err(smbl, cx, else_expr, let_expr, Some(let_pat_sym))
+                            expr_return_none_or_err(smbl, cx, if_else.unwrap(), let_expr, Some(let_pat_sym))
                         } else if is_lang_ctor(cx, qpath, ResultErr) {
                             expr_return_none_or_err(smbl, cx, if_then, let_expr, Some(let_pat_sym))
                         } else {