unused_parens now fires on cast

fix broken test

refactor: replace bool params with single enum param

bless

add more test case

fix lint implementation

correct test case

bless

bless

fix in test case

fix in library

add test case

unused_parens now fires on cast

Author: KisaragiEffective

compiler/rustc_lint/src/unused.rs

@@ -572,6 +572,7 @@ enum UnusedDelimsCtx {
     AnonConst,
     MatchArmExpr,
     IndexExpr,
+    CastExpr,
 }
 
 impl From<UnusedDelimsCtx> for &'static str {
@@ -592,10 +593,18 @@ impl From<UnusedDelimsCtx> for &'static str {
             UnusedDelimsCtx::ArrayLenExpr | UnusedDelimsCtx::AnonConst => "const expression",
             UnusedDelimsCtx::MatchArmExpr => "match arm expression",
             UnusedDelimsCtx::IndexExpr => "index expression",
+            UnusedDelimsCtx::CastExpr => "cast expression",
         }
     }
 }
 
+#[derive(Copy, Clone, Eq, PartialEq)]
+enum UnusedDelimCtxFollowedTokenKind {
+    Block,
+    Else,
+    Cast,
+}
+
 /// Used by both `UnusedParens` and `UnusedBraces` to prevent code duplication.
 trait UnusedDelimLint {
     const DELIM_STR: &'static str;
@@ -629,9 +638,14 @@ trait UnusedDelimLint {
 
     fn is_expr_delims_necessary(
         inner: &ast::Expr,
-        followed_by_block: bool,
-        followed_by_else: bool,
+        followed_token: Option<UnusedDelimCtxFollowedTokenKind>,
     ) -> bool {
+        let followed_by_block =
+            matches!(followed_token, Some(UnusedDelimCtxFollowedTokenKind::Block));
+        let followed_by_else =
+            matches!(followed_token, Some(UnusedDelimCtxFollowedTokenKind::Else));
+        let followed_by_cast =
+            matches!(followed_token, Some(UnusedDelimCtxFollowedTokenKind::Cast));
         if followed_by_else {
             match inner.kind {
                 ast::ExprKind::Binary(op, ..) if op.node.lazy() => return true,
@@ -640,6 +654,20 @@ trait UnusedDelimLint {
             }
         }
 
+        if followed_by_cast {
+            match inner.kind {
+                // `as` has higher precedence than any binary operator
+                ast::ExprKind::Binary(..)
+                // #88519
+                | ast::ExprKind::Block(..)
+                | ast::ExprKind::Match(..)
+                | ast::ExprKind::If(..)
+                // #51185
+                | ast::ExprKind::Closure(..) => return true,
+                _ => {}
+            }
+        }
+
         // Check if LHS needs parens to prevent false-positives in cases like `fn x() -> u8 { ({ 0 } + 1) }`.
         {
             let mut innermost = inner;
@@ -964,9 +992,18 @@ impl UnusedDelimLint for UnusedParens {
     ) {
         match value.kind {
             ast::ExprKind::Paren(ref inner) => {
-                let followed_by_else = ctx == UnusedDelimsCtx::AssignedValueLetElse;
-                if !Self::is_expr_delims_necessary(inner, followed_by_block, followed_by_else)
-                    && value.attrs.is_empty()
+                if !Self::is_expr_delims_necessary(
+                    inner,
+                    if followed_by_block {
+                        Some(UnusedDelimCtxFollowedTokenKind::Block)
+                    } else if ctx == UnusedDelimsCtx::AssignedValueLetElse {
+                        Some(UnusedDelimCtxFollowedTokenKind::Else)
+                    } else if ctx == UnusedDelimsCtx::CastExpr {
+                        Some(UnusedDelimCtxFollowedTokenKind::Cast)
+                    } else {
+                        None
+                    },
+                ) && value.attrs.is_empty()
                     && !value.span.from_expansion()
                     && (ctx != UnusedDelimsCtx::LetScrutineeExpr
                         || !matches!(inner.kind, ast::ExprKind::Binary(
@@ -989,6 +1026,15 @@ impl UnusedDelimLint for UnusedParens {
                     false,
                 );
             }
+            ast::ExprKind::Cast(ref expr, _) => self.check_unused_delims_expr(
+                cx,
+                expr,
+                UnusedDelimsCtx::CastExpr,
+                followed_by_block,
+                None,
+                None,
+            ),
+
             _ => {}
         }
     }
@@ -1248,10 +1294,12 @@ impl UnusedDelimLint for UnusedBraces {
                 // FIXME(const_generics): handle paths when #67075 is fixed.
                 if let [stmt] = inner.stmts.as_slice() {
                     if let ast::StmtKind::Expr(ref expr) = stmt.kind {
-                        if !Self::is_expr_delims_necessary(expr, followed_by_block, false)
-                            && (ctx != UnusedDelimsCtx::AnonConst
-                                || (matches!(expr.kind, ast::ExprKind::Lit(_))
-                                    && !expr.span.from_expansion()))
+                        if !Self::is_expr_delims_necessary(
+                            expr,
+                            followed_by_block.then_some(UnusedDelimCtxFollowedTokenKind::Block),
+                        ) && (ctx != UnusedDelimsCtx::AnonConst
+                            || (matches!(expr.kind, ast::ExprKind::Lit(_))
+                                && !expr.span.from_expansion()))
                             && !cx.sess().source_map().is_multiline(value.span)
                             && value.attrs.is_empty()
                             && !value.span.from_expansion()

library/alloc/src/sync.rs

@@ -55,7 +55,7 @@ mod tests;
 /// This is a global invariant, and also applies when using a compare-exchange loop.
 ///
 /// See comment in `Arc::clone`.
-const MAX_REFCOUNT: usize = (isize::MAX) as usize;
+const MAX_REFCOUNT: usize = isize::MAX as usize;
 
 /// The error in case either counter reaches above `MAX_REFCOUNT`, and we can `panic` safely.
 const INTERNAL_OVERFLOW_ERROR: &str = "Arc counter overflow";

library/core/src/num/dec2flt/number.rs

@@ -63,7 +63,7 @@ impl Number {
                 // normal fast path
                 let value = F::from_u64(self.mantissa);
                 if self.exponent < 0 {
-                    value / F::pow10_fast_path((-self.exponent) as _)
+                    value / F::pow10_fast_path(-self.exponent as _)
                 } else {
                     value * F::pow10_fast_path(self.exponent as _)
                 }

library/core/src/num/dec2flt/parse.rs

@@ -22,7 +22,7 @@ fn parse_8digits(mut v: u64) -> u64 {
     v = (v * 10) + (v >> 8); // will not overflow, fits in 63 bits
     let v1 = (v & MASK).wrapping_mul(MUL1);
     let v2 = ((v >> 16) & MASK).wrapping_mul(MUL2);
-    ((v1.wrapping_add(v2) >> 32) as u32) as u64
+    (v1.wrapping_add(v2) >> 32) as u32 as u64
 }
 
 /// Parse digits until a non-digit character is found.

library/core/src/num/dec2flt/slow.rs

@@ -64,7 +64,7 @@ pub(crate) fn parse_long_mantissa<F: RawFloat>(s: &[u8]) -> BiasedFp {
                 _ => 1,
             }
         } else {
-            get_shift((-d.decimal_point) as _)
+            get_shift(-d.decimal_point as _)
         };
         d.left_shift(shift);
         if d.decimal_point > Decimal::DECIMAL_POINT_RANGE {

library/std/src/io/buffered/bufreader.rs

@@ -244,8 +244,8 @@ impl<R: ?Sized + Seek> BufReader<R> {
     pub fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
         let pos = self.buf.pos() as u64;
         if offset < 0 {
-            if let Some(_) = pos.checked_sub((-offset) as u64) {
-                self.buf.unconsume((-offset) as usize);
+            if let Some(_) = pos.checked_sub(-offset as u64) {
+                self.buf.unconsume(-offset as usize);
                 return Ok(());
             }
         } else if let Some(new_pos) = pos.checked_add(offset as u64) {

library/std/src/sys/unix/os.rs

@@ -73,7 +73,7 @@ extern "C" {
 /// Returns the platform-specific value of errno
 #[cfg(not(any(target_os = "dragonfly", target_os = "vxworks")))]
 pub fn errno() -> i32 {
-    unsafe { (*errno_location()) as i32 }
+    unsafe { *errno_location() as i32 }
 }
 
 /// Sets the platform-specific value of errno

tests/ui/const-ptr/allowed_slices.rs

@@ -20,13 +20,13 @@ pub static S2: &[u32] = unsafe { from_raw_parts(&D0, 1) };
 pub static S3: &[MaybeUninit<&u32>] = unsafe { from_raw_parts(&D1, 1) };
 
 // Reinterpreting data is fine, as long as layouts match
-pub static S4: &[u8] = unsafe { from_raw_parts((&D0) as *const _ as _, 3) };
+pub static S4: &[u8] = unsafe { from_raw_parts(&D0 as *const _ as _, 3) };
 // This is only valid because D1 has uninitialized bytes, if it was an initialized pointer,
 // that would reinterpret pointers as integers which is UB in CTFE.
-pub static S5: &[MaybeUninit<u8>] = unsafe { from_raw_parts((&D1) as *const _ as _, 2) };
+pub static S5: &[MaybeUninit<u8>] = unsafe { from_raw_parts(&D1 as *const _ as _, 2) };
 // Even though u32 and [bool; 4] have different layouts, D0 has a value that
 // is valid as [bool; 4], so this is not UB (it's basically a transmute)
-pub static S6: &[bool] = unsafe { from_raw_parts((&D0) as *const _ as _, 4) };
+pub static S6: &[bool] = unsafe { from_raw_parts(&D0 as *const _ as _, 4) };
 
 // Structs are considered single allocated objects,
 // as long as you don't reinterpret padding as initialized

tests/ui/consts/issue-27890.rs

@@ -1,5 +1,5 @@
 // run-pass
-static PLUS_ONE: &'static (dyn Fn(i32) -> i32 + Sync) = (&|x: i32| { x + 1 })
+static PLUS_ONE: &'static (dyn Fn(i32) -> i32 + Sync) = &(|x: i32| { x + 1 })
     as &'static (dyn Fn(i32) -> i32 + Sync);
 
 fn main() {

tests/ui/lint/unused_parens_cast.rs

@@ -0,0 +1,101 @@
+// check-pass
+
+#![warn(unused_parens)]
+
+struct Foo(f32);
+
+impl Foo {
+    pub fn f32(self) -> f32 {
+        64.0f32
+    }
+}
+
+fn bar() -> f32 {
+    3.0f32
+}
+
+mod inner {
+    pub mod yet_inner {
+        pub mod most_inner {
+            pub static VERY_LONG_PATH: f32 = 99.0f32;
+        }
+    }
+}
+
+fn basic_test() {
+    // should fire
+    let one = 1.0f32;
+    let _ = (one) as f64;
+    //~^ WARN unnecessary parentheses around cast expression
+    let _ = (inner::yet_inner::most_inner::VERY_LONG_PATH) as f64;
+    //~^ WARN unnecessary parentheses around cast expression
+    let _ = (Foo(1.0f32).0) as f64;
+    //~^ WARN unnecessary parentheses around cast expression
+    let _ = (Foo(1.0f32).f32()) as f64;
+    //~^ WARN unnecessary parentheses around cast expression
+    let _ = (bar()) as f64;
+    //~^ WARN unnecessary parentheses around cast expression
+    let baz = [4.0f32];
+    let _ = (baz[0]) as f64;
+    //~^ WARN unnecessary parentheses around cast expression
+    let _ = (-1.0f32) as f64;
+    //~^ WARN unnecessary parentheses around cast expression
+    let x = Box::new(-1.0f32);
+    let _ = (*x) as f64;
+    //~^ WARN unnecessary parentheses around cast expression
+    // cast is left-assoc
+    let _ = (true as u8) as u16;
+    //~^ WARN unnecessary parentheses around cast expression
+    // should not fire
+    let _ = (1.0f32 * 2.0f32) as f64;
+    let _ = (1.0f32 / 2.0f32) as f64;
+    let _ = (1.0f32 % 2.0f32) as f64;
+    let _ = (1.0f32 + 2.0f32) as f64;
+    let _ = (1.0f32 - 2.0f32) as f64;
+    let _ = (42 << 1) as i64;
+    let _ = (42 >> 1) as i64;
+    let _ = (42 & 0x1F) as f64;
+    let _ = (42 ^ 0x1F) as f64;
+    let _ = (42 | 0x1F) as f64;
+    let _ = (1.0f32 == 2.0f32) as u8;
+    let _ = (1.0f32 != 2.0f32) as u8;
+    let _ = (1.0f32 < 2.0f32) as u8;
+    let _ = (1.0f32 > 2.0f32) as u8;
+    let _ = (1.0f32 <= 2.0f32) as u8;
+    let _ = (1.0f32 >= 2.0f32) as u8;
+    let _ = (true && false) as u8;
+    let _ = (true || false) as u8;
+    // skipped range: `as`-cast does not allow non-primitive cast
+    // also skipped compound operator
+}
+
+fn issue_88519() {
+    let _ = ({ 1 }) as i64;
+    let _ = (match 0 { x => x }) as i64;
+    let _ = (if true { 16 } else { 42 }) as i64;
+}
+
+fn issue_51185() -> impl Into<for<'a> fn(&'a ())> {
+    // removing parens will change semantics, and make compile does not pass
+    (|_| {}) as for<'a> fn(&'a ())
+}
+
+fn issue_clippy_10557() {
+    let x = 0f32;
+    let y = 0f32;
+    let width = 100f32;
+    let height = 100f32;
+
+    new_rect((x) as f64, (y) as f64, (width) as f64, (height) as f64);
+    //~^ WARN unnecessary parentheses around cast expression
+    //~^^ WARN unnecessary parentheses around cast expression
+    //~^^^ WARN unnecessary parentheses around cast expression
+    //~^^^^ WARN unnecessary parentheses around cast expression
+}
+
+fn new_rect(x: f64, y: f64, width: f64, height: f64) {
+
+}
+
+fn main() {
+}