clippy_lints/src/option_if_let_else.rs

   1 use crate::utils::sugg::Sugg;
   2 use crate::utils::{match_type, paths, span_lint_and_sugg};
   3 use if_chain::if_chain;
   4
   5 use rustc_errors::Applicability;
   6 use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
   7 use rustc_hir::*;
   8 use rustc_lint::{LateContext, LateLintPass};
   9 use rustc_middle::hir::map::Map;
  10 use rustc_session::{declare_lint_pass, declare_tool_lint};
  11
  12 use std::marker::PhantomData;
  13
  14 declare_clippy_lint! {
  15     /// **What it does:**
  16     /// Lints usage of  `if let Some(v) = ... { y } else { x }` which is more
  17     /// idiomatically done with `Option::map_or` (if the else bit is a simple
  18     /// expression) or `Option::map_or_else` (if the else bit is a longer
  19     /// block).
  20     ///
  21     /// **Why is this bad?**
  22     /// Using the dedicated functions of the Option type is clearer and
  23     /// more concise than an if let expression.
  24     ///
  25     /// **Known problems:**
  26     /// This lint uses whether the block is just an expression or if it has
  27     /// more statements to decide whether to use `Option::map_or` or
  28     /// `Option::map_or_else`. If you have a single expression which calls
  29     /// an expensive function, then it would be more efficient to use
  30     /// `Option::map_or_else`, but this lint would suggest `Option::map_or`.
  31     ///
  32     /// Also, this lint uses a deliberately conservative metric for checking
  33     /// if the inside of either body contains breaks or continues which will
  34     /// cause it to not suggest a fix if either block contains a loop with
  35     /// continues or breaks contained within the loop.
  36     ///
  37     /// **Example:**
  38     ///
  39     /// ```rust
  40     /// # let optional: Option<u32> = Some(0);
  41     /// let _ = if let Some(foo) = optional {
  42     ///     foo
  43     /// } else {
  44     ///     5
  45     /// };
  46     /// let _ = if let Some(foo) = optional {
  47     ///     foo
  48     /// } else {
  49     ///     let y = do_complicated_function();
  50     ///     y*y
  51     /// };
  52     /// ```
  53     ///
  54     /// should be
  55     ///
  56     /// ```rust
  57     /// # let optional: Option<u32> = Some(0);
  58     /// let _ = optional.map_or(5, |foo| foo);
  59     /// let _ = optional.map_or_else(||{
  60     ///     let y = do_complicated_function;
  61     ///     y*y
  62     /// }, |foo| foo);
  63     /// ```
  64     pub OPTION_IF_LET_ELSE,
  65     style,
  66     "reimplementation of Option::map_or"
  67 }
  68
  69 declare_lint_pass!(OptionIfLetElse => [OPTION_IF_LET_ELSE]);
  70
  71 /// Returns true iff the given expression is the result of calling Result::ok
  72 fn is_result_ok(cx: &LateContext<'_, '_>, expr: &'_ Expr<'_>) -> bool {
  73     if_chain! {
  74         if let ExprKind::MethodCall(ref path, _, &[ref receiver]) = &expr.kind;
  75         if path.ident.name.to_ident_string() == "ok";
  76         if match_type(cx, &cx.tables.expr_ty(&receiver), &paths::RESULT);
  77         then {
  78             true
  79         } else {
  80             false
  81         }
  82     }
  83 }
  84
  85 /// A struct containing information about occurences of the
  86 /// `if let Some(..) = .. else` construct that this lint detects.
  87 struct OptionIfLetElseOccurence {
  88     option: String,
  89     method_sugg: String,
  90     some_expr: String,
  91     none_expr: String,
  92 }
  93
  94 struct ReturnBreakContinueVisitor<'tcx> {
  95     seen_return_break_continue: bool,
  96     phantom_data: PhantomData<&'tcx bool>,
  97 }
  98 impl<'tcx> ReturnBreakContinueVisitor<'tcx> {
  99     fn new() -> ReturnBreakContinueVisitor<'tcx> {
 100         ReturnBreakContinueVisitor {
 101             seen_return_break_continue: false,
 102             phantom_data: PhantomData,
 103         }
 104     }
 105 }
 106 impl<'tcx> Visitor<'tcx> for ReturnBreakContinueVisitor<'tcx> {
 107     type Map = Map<'tcx>;
 108     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
 109         NestedVisitorMap::None
 110     }
 111
 112     fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
 113         if self.seen_return_break_continue {
 114             // No need to look farther if we've already seen one of them
 115             return;
 116         }
 117         match &ex.kind {
 118             ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => {
 119                 self.seen_return_break_continue = true;
 120             },
 121             // Something special could be done here to handle while or for loop
 122             // desugaring, as this will detect a break if there's a while loop
 123             // or a for loop inside the expression.
 124             _ => {
 125                 rustc_hir::intravisit::walk_expr(self, ex);
 126             },
 127         }
 128     }
 129 }
 130
 131 fn contains_return_break_continue<'tcx>(expression: &'tcx Expr<'tcx>) -> bool {
 132     let mut recursive_visitor: ReturnBreakContinueVisitor<'tcx> = ReturnBreakContinueVisitor::new();
 133     recursive_visitor.visit_expr(expression);
 134     recursive_visitor.seen_return_break_continue
 135 }
 136
 137 /// If this expression is the option if let/else construct we're detecting, then
 138 /// this function returns an OptionIfLetElseOccurence struct with details if
 139 /// this construct is found, or None if this construct is not found.
 140 fn detect_option_if_let_else<'a>(cx: &LateContext<'_, 'a>, expr: &'a Expr<'a>) -> Option<OptionIfLetElseOccurence> {
 141     //(String, String, String, String)> {
 142     if_chain! {
 143         if let ExprKind::Match(let_body, arms, MatchSource::IfLetDesugar{contains_else_clause: true}) = &expr.kind;
 144         if arms.len() == 2;
 145         if match_type(cx, &cx.tables.expr_ty(let_body), &paths::OPTION);
 146         if !is_result_ok(cx, let_body); // Don't lint on Result::ok because a different lint does it already
 147         if let PatKind::TupleStruct(_, &[inner_pat], _) = &arms[0].pat.kind;
 148         if let PatKind::Binding(_, _, id, _) = &inner_pat.kind;
 149         if !contains_return_break_continue(arms[0].body);
 150         if !contains_return_break_continue(arms[1].body);
 151         then {
 152             let some_body = if let ExprKind::Block(Block { stmts: statements, expr: Some(expr), .. }, _)
 153                 = &arms[0].body.kind {
 154                 if let &[] = &statements {
 155                     expr
 156                 } else {
 157                     &arms[0].body
 158                 }
 159             } else {
 160                 return None;
 161             };
 162             let (none_body, method_sugg) = if let ExprKind::Block(Block { stmts: statements, expr: Some(expr), .. }, _)
 163                 = &arms[1].body.kind {
 164                 if let &[] = &statements {
 165                     (expr, "map_or")
 166                 } else {
 167                     (&arms[1].body, "map_or_else")
 168                 }
 169             } else {
 170                 return None;
 171             };
 172             let capture_name = id.name.to_ident_string();
 173             Some(OptionIfLetElseOccurence {
 174                 option: format!("{}", Sugg::hir(cx, let_body, "..")),
 175                 method_sugg: format!("{}", method_sugg),
 176                 some_expr: format!("|{}| {}", capture_name, Sugg::hir(cx, some_body, "..")),
 177                 none_expr: format!("{}{}", if method_sugg == "map_or" { "" } else { "|| " }, Sugg::hir(cx, none_body, ".."))
 178             })
 179         } else {
 180             None
 181         }
 182     }
 183 }
 184
 185 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OptionIfLetElse {
 186     fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr<'_>) {
 187         if let Some(detection) = detect_option_if_let_else(cx, expr) {
 188             span_lint_and_sugg(
 189                 cx,
 190                 OPTION_IF_LET_ELSE,
 191                 expr.span,
 192                 format!("use Option::{} instead of an if let/else", detection.method_sugg).as_str(),
 193                 "try",
 194                 format!(
 195                     "{}.{}({}, {})",
 196                     detection.option, detection.method_sugg, detection.none_expr, detection.some_expr
 197                 ),
 198                 Applicability::MachineApplicable,
 199             );
 200         }
 201     }
 202 }