Add block_scrutinee lint

Author: shivendra02467

CHANGELOG.md

@@ -6561,6 +6561,7 @@ Released 2018-09-13
 [`blanket_clippy_restriction_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#blanket_clippy_restriction_lints
 [`block_in_if_condition_expr`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_in_if_condition_expr
 [`block_in_if_condition_stmt`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_in_if_condition_stmt
+[`block_scrutinee`]: https://rust-lang.github.io/rust-clippy/master/index.html#block_scrutinee
 [`blocks_in_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_conditions
 [`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
 [`bool_assert_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_assert_comparison

clippy_lints/src/block_scrutinee.rs

@@ -0,0 +1,79 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::edition::Edition;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns when a match, if let, or while let scrutinee is wrapped in a block.
+    /// This lint only triggers on the 2021 edition and older.
+    ///
+    /// ### Why is this bad?
+    /// It is unusual to write `{ expr }` when you could just have written
+    /// `expr`, and it is unlikely that anyone would write that for any reason
+    /// other than wanting temporaries in `expr` to be dropped before executing
+    /// the body of the `match`/`if let`/`while` statement. However, prior to
+    /// the 2024 edition, wrapping the scrutinee in a block did not drop
+    /// temporaries before the body executes.
+    ///
+    /// ### Example
+    /// ```rust,ignore
+    /// if let Some(x) = { my_function() } { .. }
+    /// ```
+    #[clippy::version = "1.80.0"]
+    pub BLOCK_SCRUTINEE,
+    correctness,
+    "warns when the scrutinee is wrapped in a block in older editions"
+}
+
+declare_lint_pass!(BlockScrutinee => [BLOCK_SCRUTINEE]);
+
+impl<'tcx> LateLintPass<'tcx> for BlockScrutinee {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
+        if cx.tcx.sess.edition() >= Edition::Edition2024 {
+            return;
+        }
+
+        let scrutinee = match expr.kind {
+            ExprKind::Match(scrutinee, _, _) => scrutinee,
+            ExprKind::Let(let_expr) => let_expr.init,
+            _ => return,
+        };
+
+        if let ExprKind::Block(block, _) = scrutinee.kind
+            && block.stmts.is_empty()
+            && let Some(inner_expr) = block.expr
+        {
+            let inner_snippet = snippet(cx, inner_expr.span, "..");
+
+            span_lint_and_then(
+                cx,
+                BLOCK_SCRUTINEE,
+                scrutinee.span,
+                "temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement",
+                |diag| {
+                    diag.note("this behavior is specific to Rust editions prior to 2024");
+                    diag.note("in Rust 2024, temporaries in a block scrutinee drop immediately before the match arm or block body");
+                    diag.help("if you want the temporaries to be dropped early, you can update your `Cargo.toml` to the 2024 edition");
+
+                    diag.span_suggestion(
+                        scrutinee.span,
+                        "remove the block to yield the same behavior but with cleaner code",
+                        inner_snippet.to_string(),
+                        Applicability::MachineApplicable,
+                    );
+
+                    diag.span_suggestion(
+                        scrutinee.span,
+                        "if you intended to drop temporaries early, move the expression to a separate local binding",
+                        format!("{{ let res = {inner_snippet}; res }}"),
+                        Applicability::MaybeIncorrect,
+                    );
+                },
+            );
+        }
+    }
+}

clippy_lints/src/declared_lints.rs

@@ -33,6 +33,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_LOCK_INFO,
     crate::await_holding_invalid::AWAIT_HOLDING_REFCELL_REF_INFO,
+    crate::block_scrutinee::BLOCK_SCRUTINEE_INFO,
     crate::blocks_in_conditions::BLOCKS_IN_CONDITIONS_INFO,
     crate::bool_assert_comparison::BOOL_ASSERT_COMPARISON_INFO,
     crate::bool_comparison::BOOL_COMPARISON_INFO,

clippy_lints/src/lib.rs

@@ -72,6 +72,7 @@ mod assigning_clones;
 mod async_yields_async;
 mod attrs;
 mod await_holding_invalid;
+mod block_scrutinee;
 mod blocks_in_conditions;
 mod bool_assert_comparison;
 mod bool_comparison;
@@ -869,6 +870,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
         Box::new(move |_| Box::new(manual_noop_waker::ManualNoopWaker::new(conf))),
         Box::new(|_| Box::new(byte_char_slices::ByteCharSlice)),
         Box::new(|_| Box::new(manual_assert_eq::ManualAssertEq)),
+        Box::new(|_| Box::new(block_scrutinee::BlockScrutinee)),
         // add late passes here, used by `cargo dev new_lint`
     ];
     store.late_passes.extend(late_lints);

tests/ui/block_scrutinee.1.fixed

@@ -0,0 +1,39 @@
+//@ edition: 2021
+#![warn(clippy::block_scrutinee)]
+#![allow(clippy::blocks_in_conditions)]
+#![allow(clippy::let_and_return)]
+
+fn my_function() -> Option<i32> {
+    Some(1)
+}
+
+fn main() {
+    if let Some(x) = my_function() {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        let _ = x;
+    }
+
+    match my_function() {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        Some(1) => println!("one"),
+        Some(_) => println!("other"),
+        None => println!("none"),
+    }
+
+    let mut v = vec![1, 2, 3];
+    while let Some(x) = v.pop() {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        let _ = x;
+    }
+
+    if let Some(x) = my_function() {
+        let _ = x;
+    }
+
+    if let Some(x) = {
+        let _y = 2;
+        my_function()
+    } {
+        let _ = x;
+    }
+}

tests/ui/block_scrutinee.2.fixed

@@ -0,0 +1,39 @@
+//@ edition: 2021
+#![warn(clippy::block_scrutinee)]
+#![allow(clippy::blocks_in_conditions)]
+#![allow(clippy::let_and_return)]
+
+fn my_function() -> Option<i32> {
+    Some(1)
+}
+
+fn main() {
+    if let Some(x) = { let res = my_function(); res } {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        let _ = x;
+    }
+
+    match { let res = my_function(); res } {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        Some(1) => println!("one"),
+        Some(_) => println!("other"),
+        None => println!("none"),
+    }
+
+    let mut v = vec![1, 2, 3];
+    while let Some(x) = { let res = v.pop(); res } {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        let _ = x;
+    }
+
+    if let Some(x) = my_function() {
+        let _ = x;
+    }
+
+    if let Some(x) = {
+        let _y = 2;
+        my_function()
+    } {
+        let _ = x;
+    }
+}

tests/ui/block_scrutinee.rs

@@ -0,0 +1,39 @@
+//@ edition: 2021
+#![warn(clippy::block_scrutinee)]
+#![allow(clippy::blocks_in_conditions)]
+#![allow(clippy::let_and_return)]
+
+fn my_function() -> Option<i32> {
+    Some(1)
+}
+
+fn main() {
+    if let Some(x) = { my_function() } {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        let _ = x;
+    }
+
+    match { my_function() } {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        Some(1) => println!("one"),
+        Some(_) => println!("other"),
+        None => println!("none"),
+    }
+
+    let mut v = vec![1, 2, 3];
+    while let Some(x) = { v.pop() } {
+        //~^ ERROR: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+        let _ = x;
+    }
+
+    if let Some(x) = my_function() {
+        let _ = x;
+    }
+
+    if let Some(x) = {
+        let _y = 2;
+        my_function()
+    } {
+        let _ = x;
+    }
+}

tests/ui/block_scrutinee.stderr

@@ -0,0 +1,64 @@
+error: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+  --> tests/ui/block_scrutinee.rs:11:22
+   |
+LL |     if let Some(x) = { my_function() } {
+   |                      ^^^^^^^^^^^^^^^^^
+   |
+   = note: this behavior is specific to Rust editions prior to 2024
+   = note: in Rust 2024, temporaries in a block scrutinee drop immediately before the match arm or block body
+   = help: if you want the temporaries to be dropped early, you can update your `Cargo.toml` to the 2024 edition
+   = note: `-D clippy::block-scrutinee` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::block_scrutinee)]`
+help: remove the block to yield the same behavior but with cleaner code
+   |
+LL -     if let Some(x) = { my_function() } {
+LL +     if let Some(x) = my_function() {
+   |
+help: if you intended to drop temporaries early, move the expression to a separate local binding
+   |
+LL -     if let Some(x) = { my_function() } {
+LL +     if let Some(x) = { let res = my_function(); res } {
+   |
+
+error: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+  --> tests/ui/block_scrutinee.rs:16:11
+   |
+LL |     match { my_function() } {
+   |           ^^^^^^^^^^^^^^^^^
+   |
+   = note: this behavior is specific to Rust editions prior to 2024
+   = note: in Rust 2024, temporaries in a block scrutinee drop immediately before the match arm or block body
+   = help: if you want the temporaries to be dropped early, you can update your `Cargo.toml` to the 2024 edition
+help: remove the block to yield the same behavior but with cleaner code
+   |
+LL -     match { my_function() } {
+LL +     match my_function() {
+   |
+help: if you intended to drop temporaries early, move the expression to a separate local binding
+   |
+LL -     match { my_function() } {
+LL +     match { let res = my_function(); res } {
+   |
+
+error: temporary values in this block-wrapped scrutinee will not be dropped until the end of the statement
+  --> tests/ui/block_scrutinee.rs:24:25
+   |
+LL |     while let Some(x) = { v.pop() } {
+   |                         ^^^^^^^^^^^
+   |
+   = note: this behavior is specific to Rust editions prior to 2024
+   = note: in Rust 2024, temporaries in a block scrutinee drop immediately before the match arm or block body
+   = help: if you want the temporaries to be dropped early, you can update your `Cargo.toml` to the 2024 edition
+help: remove the block to yield the same behavior but with cleaner code
+   |
+LL -     while let Some(x) = { v.pop() } {
+LL +     while let Some(x) = v.pop() {
+   |
+help: if you intended to drop temporaries early, move the expression to a separate local binding
+   |
+LL -     while let Some(x) = { v.pop() } {
+LL +     while let Some(x) = { let res = v.pop(); res } {
+   |
+
+error: aborting due to 3 previous errors
+

tests/ui/block_scrutinee_2024.rs

@@ -0,0 +1,28 @@
+//@ edition: 2024
+//@ check-pass
+#![warn(clippy::block_scrutinee)]
+#![allow(clippy::blocks_in_conditions)]
+
+fn my_function() -> Option<i32> {
+    Some(1)
+}
+
+fn main() {
+    // This should NOT trigger the lint on the 2024 edition
+    if let Some(x) = { my_function() } {
+        let _ = x;
+    }
+
+    // This should NOT trigger the lint on the 2024 edition
+    match { my_function() } {
+        Some(1) => println!("one"),
+        Some(_) => println!("other"),
+        None => println!("none"),
+    }
+
+    // This should NOT trigger the lint on the 2024 edition
+    let mut v = vec![1, 2, 3];
+    while let Some(x) = { v.pop() } {
+        let _ = x;
+    }
+}