src/tools/clippy/clippy_lints/src/needless_continue.rs

   1 //! Checks for continue statements in loops that are redundant.
   2 //!
   3 //! For example, the lint would catch
   4 //!
   5 //! ```rust
   6 //! let mut a = 1;
   7 //! let x = true;
   8 //!
   9 //! while a < 5 {
  10 //!     a = 6;
  11 //!     if x {
  12 //!         // ...
  13 //!     } else {
  14 //!         continue;
  15 //!     }
  16 //!     println!("Hello, world");
  17 //! }
  18 //! ```
  19 //!
  20 //! And suggest something like this:
  21 //!
  22 //! ```rust
  23 //! let mut a = 1;
  24 //! let x = true;
  25 //!
  26 //! while a < 5 {
  27 //!     a = 6;
  28 //!     if x {
  29 //!         // ...
  30 //!         println!("Hello, world");
  31 //!     }
  32 //! }
  33 //! ```
  34 //!
  35 //! This lint is **warn** by default.
  36 use clippy_utils::diagnostics::span_lint_and_help;
  37 use clippy_utils::source::{indent_of, snippet, snippet_block};
  38 use rustc_ast::ast;
  39 use rustc_lint::{EarlyContext, EarlyLintPass};
  40 use rustc_session::{declare_lint_pass, declare_tool_lint};
  41 use rustc_span::source_map::{original_sp, DUMMY_SP};
  42 use rustc_span::Span;
  43
  44 declare_clippy_lint! {
  45     /// **What it does:** The lint checks for `if`-statements appearing in loops
  46     /// that contain a `continue` statement in either their main blocks or their
  47     /// `else`-blocks, when omitting the `else`-block possibly with some
  48     /// rearrangement of code can make the code easier to understand.
  49     ///
  50     /// **Why is this bad?** Having explicit `else` blocks for `if` statements
  51     /// containing `continue` in their THEN branch adds unnecessary branching and
  52     /// nesting to the code. Having an else block containing just `continue` can
  53     /// also be better written by grouping the statements following the whole `if`
  54     /// statement within the THEN block and omitting the else block completely.
  55     ///
  56     /// **Known problems:** None
  57     ///
  58     /// **Example:**
  59     /// ```rust
  60     /// # fn condition() -> bool { false }
  61     /// # fn update_condition() {}
  62     /// # let x = false;
  63     /// while condition() {
  64     ///     update_condition();
  65     ///     if x {
  66     ///         // ...
  67     ///     } else {
  68     ///         continue;
  69     ///     }
  70     ///     println!("Hello, world");
  71     /// }
  72     /// ```
  73     ///
  74     /// Could be rewritten as
  75     ///
  76     /// ```rust
  77     /// # fn condition() -> bool { false }
  78     /// # fn update_condition() {}
  79     /// # let x = false;
  80     /// while condition() {
  81     ///     update_condition();
  82     ///     if x {
  83     ///         // ...
  84     ///         println!("Hello, world");
  85     ///     }
  86     /// }
  87     /// ```
  88     ///
  89     /// As another example, the following code
  90     ///
  91     /// ```rust
  92     /// # fn waiting() -> bool { false }
  93     /// loop {
  94     ///     if waiting() {
  95     ///         continue;
  96     ///     } else {
  97     ///         // Do something useful
  98     ///     }
  99     ///     # break;
 100     /// }
 101     /// ```
 102     /// Could be rewritten as
 103     ///
 104     /// ```rust
 105     /// # fn waiting() -> bool { false }
 106     /// loop {
 107     ///     if waiting() {
 108     ///         continue;
 109     ///     }
 110     ///     // Do something useful
 111     ///     # break;
 112     /// }
 113     /// ```
 114     pub NEEDLESS_CONTINUE,
 115     pedantic,
 116     "`continue` statements that can be replaced by a rearrangement of code"
 117 }
 118
 119 declare_lint_pass!(NeedlessContinue => [NEEDLESS_CONTINUE]);
 120
 121 impl EarlyLintPass for NeedlessContinue {
 122     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) {
 123         if !expr.span.from_expansion() {
 124             check_and_warn(cx, expr);
 125         }
 126     }
 127 }
 128
 129 /* This lint has to mainly deal with two cases of needless continue
 130  * statements. */
 131 // Case 1 [Continue inside else block]:
 132 //
 133 //     loop {
 134 //         // region A
 135 //         if cond {
 136 //             // region B
 137 //         } else {
 138 //             continue;
 139 //         }
 140 //         // region C
 141 //     }
 142 //
 143 // This code can better be written as follows:
 144 //
 145 //     loop {
 146 //         // region A
 147 //         if cond {
 148 //             // region B
 149 //             // region C
 150 //         }
 151 //     }
 152 //
 153 // Case 2 [Continue inside then block]:
 154 //
 155 //     loop {
 156 //       // region A
 157 //       if cond {
 158 //           continue;
 159 //           // potentially more code here.
 160 //       } else {
 161 //           // region B
 162 //       }
 163 //       // region C
 164 //     }
 165 //
 166 //
 167 // This snippet can be refactored to:
 168 //
 169 //     loop {
 170 //       // region A
 171 //       if !cond {
 172 //           // region B
 173 //           // region C
 174 //       }
 175 //     }
 176 //
 177
 178 /// Given an expression, returns true if either of the following is true
 179 ///
 180 /// - The expression is a `continue` node.
 181 /// - The expression node is a block with the first statement being a
 182 /// `continue`.
 183 fn needless_continue_in_else(else_expr: &ast::Expr, label: Option<&ast::Label>) -> bool {
 184     match else_expr.kind {
 185         ast::ExprKind::Block(ref else_block, _) => is_first_block_stmt_continue(else_block, label),
 186         ast::ExprKind::Continue(l) => compare_labels(label, l.as_ref()),
 187         _ => false,
 188     }
 189 }
 190
 191 fn is_first_block_stmt_continue(block: &ast::Block, label: Option<&ast::Label>) -> bool {
 192     block.stmts.get(0).map_or(false, |stmt| match stmt.kind {
 193         ast::StmtKind::Semi(ref e) | ast::StmtKind::Expr(ref e) => {
 194             if let ast::ExprKind::Continue(ref l) = e.kind {
 195                 compare_labels(label, l.as_ref())
 196             } else {
 197                 false
 198             }
 199         },
 200         _ => false,
 201     })
 202 }
 203
 204 /// If the `continue` has a label, check it matches the label of the loop.
 205 fn compare_labels(loop_label: Option<&ast::Label>, continue_label: Option<&ast::Label>) -> bool {
 206     match (loop_label, continue_label) {
 207         // `loop { continue; }` or `'a loop { continue; }`
 208         (_, None) => true,
 209         // `loop { continue 'a; }`
 210         (None, _) => false,
 211         // `'a loop { continue 'a; }` or `'a loop { continue 'b; }`
 212         (Some(x), Some(y)) => x.ident == y.ident,
 213     }
 214 }
 215
 216 /// If `expr` is a loop expression (while/while let/for/loop), calls `func` with
 217 /// the AST object representing the loop block of `expr`.
 218 fn with_loop_block<F>(expr: &ast::Expr, mut func: F)
 219 where
 220     F: FnMut(&ast::Block, Option<&ast::Label>),
 221 {
 222     if let ast::ExprKind::While(_, loop_block, label)
 223     | ast::ExprKind::ForLoop(_, _, loop_block, label)
 224     | ast::ExprKind::Loop(loop_block, label, ..) = &expr.kind
 225     {
 226         func(loop_block, label.as_ref());
 227     }
 228 }
 229
 230 /// If `stmt` is an if expression node with an `else` branch, calls func with
 231 /// the
 232 /// following:
 233 ///
 234 /// - The `if` expression itself,
 235 /// - The `if` condition expression,
 236 /// - The `then` block, and
 237 /// - The `else` expression.
 238 fn with_if_expr<F>(stmt: &ast::Stmt, mut func: F)
 239 where
 240     F: FnMut(&ast::Expr, &ast::Expr, &ast::Block, &ast::Expr),
 241 {
 242     match stmt.kind {
 243         ast::StmtKind::Semi(ref e) | ast::StmtKind::Expr(ref e) => {
 244             if let ast::ExprKind::If(ref cond, ref if_block, Some(ref else_expr)) = e.kind {
 245                 func(e, cond, if_block, else_expr);
 246             }
 247         },
 248         _ => {},
 249     }
 250 }
 251
 252 /// A type to distinguish between the two distinct cases this lint handles.
 253 #[derive(Copy, Clone, Debug)]
 254 enum LintType {
 255     ContinueInsideElseBlock,
 256     ContinueInsideThenBlock,
 257 }
 258
 259 /// Data we pass around for construction of help messages.
 260 struct LintData<'a> {
 261     /// The `if` expression encountered in the above loop.
 262     if_expr: &'a ast::Expr,
 263     /// The condition expression for the above `if`.
 264     if_cond: &'a ast::Expr,
 265     /// The `then` block of the `if` statement.
 266     if_block: &'a ast::Block,
 267     /// The `else` block of the `if` statement.
 268     /// Note that we only work with `if` exprs that have an `else` branch.
 269     else_expr: &'a ast::Expr,
 270     /// The 0-based index of the `if` statement in the containing loop block.
 271     stmt_idx: usize,
 272     /// The statements of the loop block.
 273     block_stmts: &'a [ast::Stmt],
 274 }
 275
 276 const MSG_REDUNDANT_ELSE_BLOCK: &str = "this `else` block is redundant";
 277
 278 const MSG_ELSE_BLOCK_NOT_NEEDED: &str = "there is no need for an explicit `else` block for this `if` \
 279                                          expression";
 280
 281 const DROP_ELSE_BLOCK_AND_MERGE_MSG: &str = "consider dropping the `else` clause and merging the code that \
 282                                              follows (in the loop) with the `if` block";
 283
 284 const DROP_ELSE_BLOCK_MSG: &str = "consider dropping the `else` clause";
 285
 286 fn emit_warning<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>, header: &str, typ: LintType) {
 287     // snip    is the whole *help* message that appears after the warning.
 288     // message is the warning message.
 289     // expr    is the expression which the lint warning message refers to.
 290     let (snip, message, expr) = match typ {
 291         LintType::ContinueInsideElseBlock => (
 292             suggestion_snippet_for_continue_inside_else(cx, data),
 293             MSG_REDUNDANT_ELSE_BLOCK,
 294             data.else_expr,
 295         ),
 296         LintType::ContinueInsideThenBlock => (
 297             suggestion_snippet_for_continue_inside_if(cx, data),
 298             MSG_ELSE_BLOCK_NOT_NEEDED,
 299             data.if_expr,
 300         ),
 301     };
 302     span_lint_and_help(
 303         cx,
 304         NEEDLESS_CONTINUE,
 305         expr.span,
 306         message,
 307         None,
 308         &format!("{}\n{}", header, snip),
 309     );
 310 }
 311
 312 fn suggestion_snippet_for_continue_inside_if<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>) -> String {
 313     let cond_code = snippet(cx, data.if_cond.span, "..");
 314
 315     let continue_code = snippet_block(cx, data.if_block.span, "..", Some(data.if_expr.span));
 316
 317     let else_code = snippet_block(cx, data.else_expr.span, "..", Some(data.if_expr.span));
 318
 319     let indent_if = indent_of(cx, data.if_expr.span).unwrap_or(0);
 320     format!(
 321         "{indent}if {} {}\n{indent}{}",
 322         cond_code,
 323         continue_code,
 324         else_code,
 325         indent = " ".repeat(indent_if),
 326     )
 327 }
 328
 329 fn suggestion_snippet_for_continue_inside_else<'a>(cx: &EarlyContext<'_>, data: &'a LintData<'_>) -> String {
 330     let cond_code = snippet(cx, data.if_cond.span, "..");
 331
 332     // Region B
 333     let block_code = erode_from_back(&snippet_block(cx, data.if_block.span, "..", Some(data.if_expr.span)));
 334
 335     // Region C
 336     // These is the code in the loop block that follows the if/else construction
 337     // we are complaining about. We want to pull all of this code into the
 338     // `then` block of the `if` statement.
 339     let indent = span_of_first_expr_in_block(data.if_block)
 340         .and_then(|span| indent_of(cx, span))
 341         .unwrap_or(0);
 342     let to_annex = data.block_stmts[data.stmt_idx + 1..]
 343         .iter()
 344         .map(|stmt| original_sp(stmt.span, DUMMY_SP))
 345         .map(|span| {
 346             let snip = snippet_block(cx, span, "..", None).into_owned();
 347             snip.lines()
 348                 .map(|line| format!("{}{}", " ".repeat(indent), line))
 349                 .collect::<Vec<_>>()
 350                 .join("\n")
 351         })
 352         .collect::<Vec<_>>()
 353         .join("\n");
 354
 355     let indent_if = indent_of(cx, data.if_expr.span).unwrap_or(0);
 356     format!(
 357         "{indent_if}if {} {}\n{indent}// merged code follows:\n{}\n{indent_if}}}",
 358         cond_code,
 359         block_code,
 360         to_annex,
 361         indent = " ".repeat(indent),
 362         indent_if = " ".repeat(indent_if),
 363     )
 364 }
 365
 366 fn check_and_warn<'a>(cx: &EarlyContext<'_>, expr: &'a ast::Expr) {
 367     with_loop_block(expr, |loop_block, label| {
 368         for (i, stmt) in loop_block.stmts.iter().enumerate() {
 369             with_if_expr(stmt, |if_expr, cond, then_block, else_expr| {
 370                 let data = &LintData {
 371                     stmt_idx: i,
 372                     if_expr,
 373                     if_cond: cond,
 374                     if_block: then_block,
 375                     else_expr,
 376                     block_stmts: &loop_block.stmts,
 377                 };
 378                 if needless_continue_in_else(else_expr, label) {
 379                     emit_warning(
 380                         cx,
 381                         data,
 382                         DROP_ELSE_BLOCK_AND_MERGE_MSG,
 383                         LintType::ContinueInsideElseBlock,
 384                     );
 385                 } else if is_first_block_stmt_continue(then_block, label) {
 386                     emit_warning(cx, data, DROP_ELSE_BLOCK_MSG, LintType::ContinueInsideThenBlock);
 387                 }
 388             });
 389         }
 390     });
 391 }
 392
 393 /// Eats at `s` from the end till a closing brace `}` is encountered, and then continues eating
 394 /// till a non-whitespace character is found.  e.g., the string. If no closing `}` is present, the
 395 /// string will be preserved.
 396 ///
 397 /// ```rust
 398 /// {
 399 ///     let x = 5;
 400 /// }
 401 /// ```
 402 ///
 403 /// is transformed to
 404 ///
 405 /// ```ignore
 406 ///     {
 407 ///         let x = 5;
 408 /// ```
 409 #[must_use]
 410 fn erode_from_back(s: &str) -> String {
 411     let mut ret = s.to_string();
 412     while ret.pop().map_or(false, |c| c != '}') {}
 413     while let Some(c) = ret.pop() {
 414         if !c.is_whitespace() {
 415             ret.push(c);
 416             break;
 417         }
 418     }
 419     if ret.is_empty() { s.to_string() } else { ret }
 420 }
 421
 422 fn span_of_first_expr_in_block(block: &ast::Block) -> Option<Span> {
 423     block.stmts.get(0).map(|stmt| stmt.span)
 424 }
 425
 426 #[cfg(test)]
 427 mod test {
 428     use super::erode_from_back;
 429
 430     #[test]
 431     #[rustfmt::skip]
 432     fn test_erode_from_back() {
 433         let input = "\
 434 {
 435     let x = 5;
 436     let y = format!(\"{}\", 42);
 437 }";
 438
 439         let expected = "\
 440 {
 441     let x = 5;
 442     let y = format!(\"{}\", 42);";
 443
 444         let got = erode_from_back(input);
 445         assert_eq!(expected, got);
 446     }
 447
 448     #[test]
 449     #[rustfmt::skip]
 450     fn test_erode_from_back_no_brace() {
 451         let input = "\
 452 let x = 5;
 453 let y = something();
 454 ";
 455         let expected = input;
 456         let got = erode_from_back(input);
 457         assert_eq!(expected, got);
 458     }
 459 }