Preserve parentheses around unary operators in method invocation select (#6663)

* Preserve parentheses around unary operators in method invocation select

When the select expression of a method invocation is a parenthesized unary
operator like (++i).toString(), the parentheses are required. Without them,
++i.toString() is a syntax error because the . operator has higher precedence
than ++.

The fix adds J.Unary to the list of expression types that should retain their
parentheses in visitMethodInvocation, alongside Assignment, Binary, Ternary,
TypeCast, and SwitchExpression.

Fixes moderneinc/customer-requests#1790

* Add tests for unwrapping unary operators in assignment and argument contexts

Adds tests to verify that unnecessary parentheses around unary operators
(++i, i++, --i, i--) are correctly removed when they appear in:
- Variable initializers: int x = (++i) → int x = ++i
- Method arguments: println((++i)) → println(++i)

These complement the methodInvocationSelectUnary test which verifies that
parentheses are preserved when required (i.e., (++i).toString()).

Author: dsgrieve

rewrite-java-test/src/test/java/org/openrewrite/java/cleanup/UnnecessaryParenthesesTest.java

@@ -932,6 +932,63 @@ boolean falseMethod() {
         );
     }
 
+    @Test
+    void unwrapUnaryInAssignment() {
+        rewriteRun(
+          unnecessaryParentheses(style -> style.withAssign(true)),
+          java(
+            """
+              class Test {
+                  void test() {
+                      int i = 1;
+                      int a = (++i);
+                      int b = (i++);
+                      int c = (--i);
+                      int d = (i--);
+                  }
+              }
+              """,
+            """
+              class Test {
+                  void test() {
+                      int i = 1;
+                      int a = ++i;
+                      int b = i++;
+                      int c = --i;
+                      int d = i--;
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @Test
+    void unwrapUnaryInMethodArgument() {
+        rewriteRun(
+          java(
+            """
+              class Test {
+                  void test() {
+                      int i = 1;
+                      System.out.println((++i));
+                      System.out.println((i++));
+                  }
+              }
+              """,
+            """
+              class Test {
+                  void test() {
+                      int i = 1;
+                      System.out.println(++i);
+                      System.out.println(i++);
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @ExpectedToFail("Not implemented yet")
     @Test
     void unwrapBinaryInIf() {
@@ -1140,6 +1197,54 @@ void f(Object x) {
               )
             );
         }
+
+        @Issue("https://github.com/moderneinc/customer-requests/issues/1790")
+        @Test
+        void methodInvocationSelectUnary() {
+            //language=java
+            rewriteRun(
+              java(
+                """
+                  class A {
+                    void f() {
+                      Integer i = Integer.valueOf(1);
+                      String s = (++i).toString();
+                    }
+                  }
+                  """
+              ),
+              java(
+                """
+                  class B {
+                    void f() {
+                      Integer i = Integer.valueOf(1);
+                      String s = (i++).toString();
+                    }
+                  }
+                  """
+              ),
+              java(
+                """
+                  class C {
+                    void f() {
+                      Integer i = Integer.valueOf(1);
+                      String s = (--i).toString();
+                    }
+                  }
+                  """
+              ),
+              java(
+                """
+                  class D {
+                    void f() {
+                      Integer i = Integer.valueOf(1);
+                      String s = (i--).toString();
+                    }
+                  }
+                  """
+              )
+            );
+        }
     }
 
     @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/534")

rewrite-java/src/main/java/org/openrewrite/java/cleanup/UnnecessaryParenthesesVisitor.java

@@ -226,7 +226,8 @@ public J visitMethodInvocation(J.MethodInvocation method, P p) {
                     parentheses.getTree() instanceof J.Binary ||
                     parentheses.getTree() instanceof J.Ternary ||
                     parentheses.getTree() instanceof J.TypeCast ||
-                    parentheses.getTree() instanceof J.SwitchExpression) {
+                    parentheses.getTree() instanceof J.SwitchExpression ||
+                    parentheses.getTree() instanceof J.Unary) {
                 return mi;
             }
             Expression tree = (Expression) parentheses.getTree();