Lint unused parentheses around method receiver

Extend the `unused_parens` lint to detect unnecessary parentheses around
method receivers like `(x).method()`. Previously, the lint only checked
method arguments but not the receiver.

The fix adds a new `MethodReceiver` context to `UnusedDelimsCtx` and
checks method call receivers in `check_expr()`. It also handles cases
where parentheses are necessary, such as:
- Range expressions: `(1..10).sum()`
- Unary expressions: `(*ptr).method()`, `(-1).abs()`
- Binary expressions: `(1 + 2).to_string()`
- Cast expressions: `(x as i32).abs()`
- Type expressions, assignments, and address-of expressions

Also removes unnecessary parentheses from the standard library that
were caught by the new lint.

Fixes #151985

Author: chenyukang

compiler/rustc_lint/src/unused.rs

@@ -623,6 +623,7 @@ impl<'tcx> LateLintPass<'tcx> for PathStatements {
 enum UnusedDelimsCtx {
     FunctionArg,
     MethodArg,
+    MethodReceiver,
     AssignedValue,
     AssignedValueLetElse,
     IfCond,
@@ -645,6 +646,7 @@ impl From<UnusedDelimsCtx> for &'static str {
         match ctx {
             UnusedDelimsCtx::FunctionArg => "function argument",
             UnusedDelimsCtx::MethodArg => "method argument",
+            UnusedDelimsCtx::MethodReceiver => "method receiver",
             UnusedDelimsCtx::AssignedValue | UnusedDelimsCtx::AssignedValueLetElse => {
                 "assigned value"
             }
@@ -710,6 +712,22 @@ trait UnusedDelimLint {
             }
         }
 
+        // For method receivers, parentheses are necessary for certain expression types
+        // to avoid parsing ambiguities, e.g. `(1..10).sum()`, `(*ptr).method()`, etc.
+        if ctx == UnusedDelimsCtx::MethodReceiver {
+            match inner.kind {
+                ast::ExprKind::Range(..)
+                | ast::ExprKind::Unary(..)
+                | ast::ExprKind::Binary(..)
+                | ast::ExprKind::Cast(..)
+                | ast::ExprKind::Type(..)
+                | ast::ExprKind::Assign(..)
+                | ast::ExprKind::AssignOp(..)
+                | ast::ExprKind::AddrOf(..) => return true,
+                _ => {}
+            }
+        }
+
         // Check it's range in LetScrutineeExpr
         if let ast::ExprKind::Range(..) = inner.kind
             && matches!(ctx, UnusedDelimsCtx::LetScrutineeExpr)
@@ -976,13 +994,15 @@ trait UnusedDelimLint {
             }
             // either function/method call, or something this lint doesn't care about
             ref call_or_other => {
-                let (args_to_check, ctx) = match *call_or_other {
-                    Call(_, ref args) => (&args[..], UnusedDelimsCtx::FunctionArg),
-                    MethodCall(ref call) => (&call.args[..], UnusedDelimsCtx::MethodArg),
+                let (args_to_check, ctx, receiver) = match *call_or_other {
+                    Call(_, ref args) => (&args[..], UnusedDelimsCtx::FunctionArg, None),
+                    MethodCall(ref call) => {
+                        (&call.args[..], UnusedDelimsCtx::MethodArg, Some(&call.receiver))
+                    }
                     Closure(ref closure)
                         if matches!(closure.fn_decl.output, FnRetTy::Default(_)) =>
                     {
-                        (&[closure.body.clone()][..], UnusedDelimsCtx::ClosureBody)
+                        (&[closure.body.clone()][..], UnusedDelimsCtx::ClosureBody, None)
                     }
                     // actual catch-all arm
                     _ => {
@@ -999,6 +1019,17 @@ trait UnusedDelimLint {
                 for arg in args_to_check {
                     self.check_unused_delims_expr(cx, arg, ctx, false, None, None, false);
                 }
+                if let Some(recv) = receiver {
+                    self.check_unused_delims_expr(
+                        cx,
+                        recv,
+                        UnusedDelimsCtx::MethodReceiver,
+                        false,
+                        None,
+                        None,
+                        false,
+                    );
+                }
                 return;
             }
         };

library/alloc/src/rc.rs

@@ -874,7 +874,7 @@ impl<T, A: Allocator> Rc<T, A> {
             },
             alloc,
         ));
-        let uninit_ptr: NonNull<_> = (unsafe { &mut *uninit_raw_ptr }).into();
+        let uninit_ptr: NonNull<_> = unsafe { &mut *uninit_raw_ptr }.into();
         let init_ptr: NonNull<RcInner<T>> = uninit_ptr.cast();
 
         let weak = Weak { ptr: init_ptr, alloc };
@@ -3242,7 +3242,7 @@ impl<T, A: Allocator> Weak<T, A> {
 }
 
 pub(crate) fn is_dangling<T: ?Sized>(ptr: *const T) -> bool {
-    (ptr.cast::<()>()).addr() == usize::MAX
+    ptr.cast::<()>().addr() == usize::MAX
 }
 
 /// Helper type to allow accessing the reference counts without

library/alloc/src/slice.rs

@@ -534,7 +534,7 @@ impl<T> [T] {
                 unsafe {
                     ptr::copy_nonoverlapping::<T>(
                         buf.as_ptr(),
-                        (buf.as_mut_ptr()).add(buf.len()),
+                        buf.as_mut_ptr().add(buf.len()),
                         buf.len(),
                     );
                     // `buf` has capacity of `self.len() * n`.
@@ -555,7 +555,7 @@ impl<T> [T] {
                 // This is non-overlapping since `2^expn > rem`.
                 ptr::copy_nonoverlapping::<T>(
                     buf.as_ptr(),
-                    (buf.as_mut_ptr()).add(buf.len()),
+                    buf.as_mut_ptr().add(buf.len()),
                     rem_len,
                 );
                 // `buf.len() + rem_len` equals to `buf.capacity()` (`= self.len() * n`).

library/alloc/src/sync.rs

@@ -893,7 +893,7 @@ impl<T, A: Allocator> Arc<T, A> {
             },
             alloc,
         ));
-        let uninit_ptr: NonNull<_> = (unsafe { &mut *uninit_raw_ptr }).into();
+        let uninit_ptr: NonNull<_> = unsafe { &mut *uninit_raw_ptr }.into();
         let init_ptr: NonNull<ArcInner<T>> = uninit_ptr.cast();
 
         let weak = Weak { ptr: init_ptr, alloc };

library/compiler-builtins/libm/src/math/cbrt.rs

@@ -194,7 +194,7 @@ pub fn cbrt_round(x: f64, round: Round) -> FpResult<f64> {
         let mut cvt4: u64 = y1.to_bits();
         cvt4 = (cvt4 + (164 << 15)) & 0xffffffffffff0000u64;
 
-        if ((f64::from_bits(cvt4) - y1) - dy).abs() < hf64!("0x1p-60") || (zz).abs() == 1.0 {
+        if ((f64::from_bits(cvt4) - y1) - dy).abs() < hf64!("0x1p-60") || zz.abs() == 1.0 {
             cvt3 = (cvt3 + (1u64 << 15)) & 0xffffffffffff0000u64;
         }
     }

library/core/src/ptr/const_ptr.rs

@@ -27,7 +27,7 @@ impl<T: PointeeSized> *const T {
             @capture { ptr: *const u8 } -> bool:
             // This use of `const_raw_ptr_comparison` has been explicitly blessed by t-lang.
             if const #[rustc_allow_const_fn_unstable(const_raw_ptr_comparison)] {
-                match (ptr).guaranteed_eq(null_mut()) {
+                match ptr.guaranteed_eq(null_mut()) {
                     Some(res) => res,
                     // To remain maximally conservative, we stop execution when we don't
                     // know whether the pointer is null or not.

tests/ui/lint/unused-parens-method-receiver-issue-151985.fixed

@@ -0,0 +1,22 @@
+//@ run-rustfix
+
+#![deny(unused_parens)]
+
+struct Thing;
+impl Thing {
+    fn method(self) {}
+}
+
+fn main() {
+    // Unnecessary parens - should warn
+    let x = Thing;
+    x.method(); //~ ERROR unnecessary parentheses around method receiver
+
+    // Necessary parens - should NOT warn
+    let _ = (1..10).sum::<i32>();           // Range expression
+    let _ = (1_i32 + 2).abs();               // Binary expression
+    let _ = (-1_i32).abs();                  // Unary expression
+    let _ = (true as i32).abs();             // Cast expression
+    let _ = (&42).clone();                   // AddrOf expression
+    let _ = (&mut 42).clone();               // AddrOf mut expression
+}

tests/ui/lint/unused-parens-method-receiver-issue-151985.rs

@@ -0,0 +1,22 @@
+//@ run-rustfix
+
+#![deny(unused_parens)]
+
+struct Thing;
+impl Thing {
+    fn method(self) {}
+}
+
+fn main() {
+    // Unnecessary parens - should warn
+    let x = Thing;
+    (x).method(); //~ ERROR unnecessary parentheses around method receiver
+
+    // Necessary parens - should NOT warn
+    let _ = (1..10).sum::<i32>();           // Range expression
+    let _ = (1_i32 + 2).abs();               // Binary expression
+    let _ = (-1_i32).abs();                  // Unary expression
+    let _ = (true as i32).abs();             // Cast expression
+    let _ = (&42).clone();                   // AddrOf expression
+    let _ = (&mut 42).clone();               // AddrOf mut expression
+}

tests/ui/lint/unused-parens-method-receiver-issue-151985.stderr

@@ -0,0 +1,19 @@
+error: unnecessary parentheses around method receiver
+  --> $DIR/unused-parens-method-receiver-issue-151985.rs:13:5
+   |
+LL |     (x).method();
+   |     ^ ^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-parens-method-receiver-issue-151985.rs:3:9
+   |
+LL | #![deny(unused_parens)]
+   |         ^^^^^^^^^^^^^
+help: remove these parentheses
+   |
+LL -     (x).method();
+LL +     x.method();
+   |
+
+error: aborting due to 1 previous error
+