Improve changes

Author: ChAoSUnItY

compiler/rustc_lint/src/unused.rs

@@ -656,6 +656,25 @@ trait UnusedDelimLint {
         is_kw: bool,
     );
 
+    #[inline]
+    fn impacts_followed_by_block(e: &ast::Expr) -> bool {
+        return match e.kind {
+            ExprKind::Block(..) | ExprKind::Call(..) | ExprKind::MethodCall(..) => true,
+            _ => Self::is_followed_by_block(e),
+        };
+    }
+
+    #[inline]
+    fn is_followed_by_block(e: &ast::Expr) -> bool {
+        return match e.kind {
+            ExprKind::If(ref cond, ..) if !matches!(cond.kind, ExprKind::Let(..)) => true,
+            ExprKind::While(ref cond, ..) if !matches!(cond.kind, ExprKind::Let(..)) => true,
+            ExprKind::ForLoop { .. } => true,
+            ExprKind::Match(_, _, ast::MatchKind::Prefix) => true,
+            _ => false,
+        };
+    }
+
     fn is_expr_delims_necessary(
         inner: &ast::Expr,
         ctx: UnusedDelimsCtx,
@@ -1050,6 +1069,7 @@ pub(crate) struct UnusedParens {
     /// `1 as (i32) < 2` parses to ExprKind::Lt
     /// `1 as i32 < 2` parses to i32::<2[missing angle bracket]
     parens_in_cast_in_lt: Vec<ast::NodeId>,
+<<<<<<< HEAD
     /// Ty nodes in this map are in TypeNoBounds position. Any bounds they
     /// contain may be ambiguous w/r/t trailing `+` operators.
     in_no_bounds_pos: FxHashMap<ast::NodeId, NoBoundsException>,
@@ -1075,6 +1095,12 @@ enum NoBoundsException {
     /// The type is the last bound of the containing type expression. If it has exactly one bound,
     /// parentheses around the type are unnecessary.
     OneBound,
+=======
+    // Used for tracking parent expressions that would immediately followed
+    // by block. Storing false here indicates that expression itself is Block
+    // expression. This is meant for to prevent report false positive cases.
+    followed_by_block: Vec<bool>,
+>>>>>>> 5c02bc9efda (Improve changes)
 }
 
 impl_lint_pass!(UnusedParens => [UNUSED_PARENS]);
@@ -1477,32 +1503,14 @@ declare_lint! {
 
 #[derive(Default)]
 pub(crate) struct UnusedBraces {
-    parent_followed_by_block: Vec<bool>,
+    // Used for tracking parent expressions that would immediately followed
+    // by block. Storing false here indicates that expression itself is Block
+    // expression. This is meant for to prevent report false positive cases.
+    followed_by_block: Vec<bool>,
 }
 
 impl_lint_pass!(UnusedBraces => [UNUSED_BRACES]);
 
-impl UnusedBraces {
-    #[inline]
-    fn should_mark_block(e: &ast::Expr) -> bool {
-        return match e.kind {
-            ExprKind::Block(..) => true,
-            _ => Self::is_followed_by_block(e),
-        };
-    }
-
-    #[inline]
-    fn is_followed_by_block(e: &ast::Expr) -> bool {
-        return match e.kind {
-            ExprKind::If(ref cond, ..) if !matches!(cond.kind, ExprKind::Let(..)) => true,
-            ExprKind::While(ref cond, ..) if !matches!(cond.kind, ExprKind::Let(..)) => true,
-            ExprKind::ForLoop { .. } => true,
-            ExprKind::Match(_, _, ast::MatchKind::Prefix) => true,
-            _ => false,
-        };
-    }
-}
-
 impl UnusedDelimLint for UnusedBraces {
     const DELIM_STR: &'static str = "braces";
 
@@ -1600,8 +1608,8 @@ impl EarlyLintPass for UnusedBraces {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) {
         <Self as UnusedDelimLint>::check_expr(self, cx, e);
 
-        if Self::should_mark_block(e) {
-            self.parent_followed_by_block.push(Self::is_followed_by_block(e));
+        if <Self as UnusedDelimLint>::impacts_followed_by_block(e) {
+            self.followed_by_block.push(<Self as UnusedDelimLint>::is_followed_by_block(e));
         }
 
         if let ExprKind::Repeat(_, ref anon_const) = e.kind {
@@ -1618,11 +1626,9 @@ impl EarlyLintPass for UnusedBraces {
     }
 
     fn check_expr_post(&mut self, _cx: &EarlyContext<'_>, e: &ast::Expr) {
-        if Self::should_mark_block(e) {
-            let followed_by_block = self
-                .parent_followed_by_block
-                .pop()
-                .expect("check_expr and check_expr_post must balance");
+        if <Self as UnusedDelimLint>::impacts_followed_by_block(e) {
+            let followed_by_block =
+                self.followed_by_block.pop().expect("check_expr and check_expr_post must balance");
             assert_eq!(
                 followed_by_block,
                 Self::is_followed_by_block(e),

tests/ui/lint/unused/unused-braces-respect-parent-block-issue-141783.fixed

@@ -1,13 +1,25 @@
 //@ run-rustfix
 //@ check-pass
 #[allow(unreachable_code)]
+#[allow(unused)]
 #[warn(unused_braces)]
+#[warn(unused_parens)]
 
 fn main() {
     return return; //~ WARN: unnecessary braces
+    if f(return) {} else {} //~ WARN: unnecessary braces
     if return { return } { return } else { return }
     match return { return } {
         _ => { return }
     }
     while return { return } {}
+    loop {
+        if break Foo {}
+    };
+}
+
+struct Foo;
+
+fn f(_a: ()) -> bool {
+    true
 }

tests/ui/lint/unused/unused-braces-respect-parent-block-issue-141783.rs

@@ -1,13 +1,25 @@
 //@ run-rustfix
 //@ check-pass
 #[allow(unreachable_code)]
+#[allow(unused)]
 #[warn(unused_braces)]
+#[warn(unused_parens)]
 
 fn main() {
     return { return }; //~ WARN: unnecessary braces
+    if f({ return }) {} else {} //~ WARN: unnecessary braces
     if return { return } { return } else { return }
     match return { return } {
         _ => { return }
     }
     while return { return } {}
+    loop {
+        if break (Foo) {}
+    };
+}
+
+struct Foo;
+
+fn f(_a: ()) -> bool {
+    true
 }

tests/ui/lint/unused/unused-braces-respect-parent-block-issue-141783.stderr

@@ -1,11 +1,11 @@
 warning: unnecessary braces around `return` value
-  --> $DIR/unused-braces-respect-parent-block-issue-141783.rs:7:12
+  --> $DIR/unused-braces-respect-parent-block-issue-141783.rs:9:12
    |
 LL |     return { return };
    |            ^^      ^^
    |
 note: the lint level is defined here
-  --> $DIR/unused-braces-respect-parent-block-issue-141783.rs:4:8
+  --> $DIR/unused-braces-respect-parent-block-issue-141783.rs:5:8
    |
 LL | #[warn(unused_braces)]
    |        ^^^^^^^^^^^^^
@@ -15,5 +15,34 @@ LL -     return { return };
 LL +     return return;
    |
 
-warning: 1 warning emitted
+warning: unnecessary braces around function argument
+  --> $DIR/unused-braces-respect-parent-block-issue-141783.rs:10:10
+   |
+LL |     if f({ return }) {} else {}
+   |          ^^      ^^
+   |
+help: remove these braces
+   |
+LL -     if f({ return }) {} else {}
+LL +     if f(return) {} else {}
+   |
+
+warning: unnecessary parentheses around `break` value
+  --> $DIR/unused-braces-respect-parent-block-issue-141783.rs:17:18
+   |
+LL |         if break (Foo) {}
+   |                  ^   ^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-braces-respect-parent-block-issue-141783.rs:6:8
+   |
+LL | #[warn(unused_parens)]
+   |        ^^^^^^^^^^^^^
+help: remove these parentheses
+   |
+LL -         if break (Foo) {}
+LL +         if break Foo {}
+   |
+
+warning: 3 warnings emitted