fix(rustc_lint): better detect when parens are necessary

Fixes rust-lang#88519

compiler/rustc_lint/src/unused.rs

@@ -461,13 +461,16 @@ trait UnusedDelimLint {
         let lhs_needs_parens = {
             let mut innermost = inner;
             loop {
-                if let ExprKind::Binary(_, lhs, _rhs) = &innermost.kind {
-                    innermost = lhs;
-                    if !classify::expr_requires_semi_to_be_stmt(innermost) {
-                        break true;
-                    }
-                } else {
-                    break false;
+                innermost = match &innermost.kind {
+                    ExprKind::Binary(_, lhs, _rhs) => lhs,
+                    ExprKind::Call(fn_, _params) => fn_,
+                    ExprKind::Cast(expr, _ty) => expr,
+                    ExprKind::Type(expr, _ty) => expr,
+                    ExprKind::Index(base, _subscript) => base,
+                    _ => break false,
+                };
+                if !classify::expr_requires_semi_to_be_stmt(innermost) {
+                    break true;
                 }
             }
         };

src/test/ui/lint/unused/issue-88519-unused-paren.rs

@@ -0,0 +1,94 @@
+// check-pass
+// Make sure unused parens lint doesn't emit a false positive.
+// See https://github.com/rust-lang/rust/issues/88519
+#![deny(unused_parens)]
+#![feature(type_ascription)]
+
+// binary ops are tested in issue-71290-unused-paren-binop.rs
+
+mod call {
+    fn noop() -> u8 { 0 }
+    fn outside() -> u8 {
+        ({ noop })()
+    }
+    fn inside() -> u8 {
+        ({ noop }())
+    }
+    fn outside_match() -> u8 {
+        (match noop { x => x })()
+    }
+    fn inside_match() -> u8 {
+        (match noop { x => x }())
+    }
+    fn outside_if() -> u8 {
+        (if false { noop } else { noop })()
+    }
+    fn inside_if() -> u8 {
+        (if false { noop } else { noop }())
+    }
+}
+
+mod casts {
+    fn outside() -> u8 {
+        ({ 0 }) as u8
+    }
+    fn inside() -> u8 {
+        ({ 0 } as u8)
+    }
+    fn outside_match() -> u8 {
+        (match 0 { x => x }) as u8
+    }
+    fn inside_match() -> u8 {
+        (match 0 { x => x } as u8)
+    }
+    fn outside_if() -> u8 {
+        (if false { 0 } else { 0 }) as u8
+    }
+    fn inside_if() -> u8 {
+        (if false { 0 } else { 0 } as u8)
+    }
+}
+
+mod typeascription {
+    fn outside() -> u8 {
+        ({ 0 }): u8
+    }
+    fn inside() -> u8 {
+        ({ 0 }: u8)
+    }
+    fn outside_match() -> u8 {
+        (match 0 { x => x }): u8
+    }
+    fn inside_match() -> u8 {
+        (match 0 { x => x }: u8)
+    }
+    fn outside_if() -> u8 {
+        (if false { 0 } else { 0 }): u8
+    }
+    fn inside_if() -> u8 {
+        (if false { 0 } else { 0 }: u8)
+    }
+}
+
+mod index {
+    fn outside(x: &[u8]) -> u8 {
+        ({ x })[0]
+    }
+    fn inside(x: &[u8]) -> u8 {
+        ({ x }[0])
+    }
+    fn outside_match(x: &[u8]) -> u8 {
+        (match x { x => x })[0]
+    }
+    fn inside_match(x: &[u8]) -> u8 {
+        (match x { x => x }[0])
+    }
+    fn outside_if(x: &[u8]) -> u8 {
+        (if false { x } else { x })[0]
+    }
+    fn inside_if(x: &[u8]) -> u8 {
+        (if false { x } else { x }[0])
+    }
+}
+
+fn main() {}