Handling parentheses sometimes needed around instanceof

src/main/java/org/openrewrite/staticanalysis/ReplaceClassIsInstanceWithInstanceof.java

@@ -33,6 +33,7 @@
 import org.openrewrite.java.tree.JavaType;
 
 import java.util.Collections;
+import java.util.function.Function;
 import java.util.Set;
 
 public class ReplaceClassIsInstanceWithInstanceof extends Recipe {
@@ -68,15 +69,29 @@ public J visitMethodInvocation(MethodInvocation method, ExecutionContext ctx) {
                     FieldAccess fieldAccessPart = (FieldAccess) method.getSelect();
                     // upcast to type J, so J.MethodInvocation can be replaced by J.InstanceOf
                     JavaCoordinates coordinates = method.getCoordinates().replace();
-                    J.InstanceOf instanceOf = JavaTemplate.builder("#{any()} instanceof Object")
+                    J updated = JavaTemplate.builder("#{any()} instanceof Object")
                             .build()
                             .apply(getCursor(), coordinates, objectExpression);
-                    instanceOf = instanceOf.withClazz(fieldAccessPart.getTarget().withPrefix(instanceOf.getClazz().getPrefix()));
-                    return maybeAutoFormat(method, instanceOf, ctx);
+                    updated = mapInstanceOf(updated,
+                            instanceOf -> instanceOf.withClazz(fieldAccessPart.getTarget().withPrefix(instanceOf.getClazz().getPrefix())));
+                    return maybeAutoFormat(method, updated, ctx);
                 }
                 return super.visitMethodInvocation(method, ctx);
             }
 
+            private J mapInstanceOf(J tree, Function<J.InstanceOf, J.InstanceOf> fun) {
+                if (tree instanceof J.InstanceOf) {
+                    return fun.apply((J.InstanceOf) tree);
+                }
+                if (tree instanceof J.Parentheses) {
+                    J.Parentheses<J> par = (J.Parentheses<J>) tree;
+                    J inner = mapInstanceOf(par.getTree(), fun);
+                    return par.withTree(inner);
+                } else {
+                    throw new IllegalArgumentException("Expected J.InstanceOf or J.Parentheses, but got: " + tree.getClass());
+                }
+            }
+
             private boolean isObjectClass(@Nullable Expression expression) {
                 if (expression instanceof J.FieldAccess) {
                     J.FieldAccess fieldAccess = (J.FieldAccess) expression;

src/test/java/org/openrewrite/staticanalysis/ReplaceClassIsInstanceWithInstanceofTest.java

@@ -282,4 +282,32 @@ boolean foo(Object obj) {
         );
     }
 
+    @Test
+    void parensAroundInstanceOf() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              class A {
+                  boolean foo(Object one, Object two) {
+                      if (one == null || !String.class.isInstance(two)) {
+                          return false;
+                      }
+                      return true;
+                  }
+              }
+            """,
+            """
+            class A {
+                boolean foo(Object one, Object two) {
+                    if (one == null || !(two instanceof String)) {
+                        return false;
+                    }
+                    return true;
+                }
+            }
+            """
+          )
+        );
+    }
 }