Fix ClassCastException on parenthesized initializers in var recipes (#1064)

`UseVarForConstructors` and `UseVarForGenericMethodInvocations` unwrap
the initializer for local `instanceof` checks but pass the original
`VariableDeclarations` (still wrapping `J.Parentheses`) to downstream
casts/`transformToVar`, which re-fetch and cast the raw initializer.
Rewrite the declaration to use the unwrapped initializer (preserving
the original prefix) before handing it off.

Author: knutwannheden

src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForConstructors.java

@@ -21,6 +21,7 @@
 import org.openrewrite.Preconditions;
 import org.openrewrite.Recipe;
 import org.openrewrite.TreeVisitor;
+import org.openrewrite.internal.ListUtils;
 import org.openrewrite.java.JavaIsoVisitor;
 import org.openrewrite.java.search.UsesJavaVersion;
 import org.openrewrite.java.tree.*;
@@ -57,11 +58,11 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations v
                     return vd;
                 }
 
-                Expression initializer = vd.getVariables().get(0).getInitializer();
-                if (initializer == null) {
+                Expression originalInitializer = vd.getVariables().get(0).getInitializer();
+                if (originalInitializer == null) {
                     return vd;
                 }
-                initializer = initializer.unwrap();
+                Expression initializer = originalInitializer.unwrap();
 
                 // Only transform constructor calls
                 if (!(initializer instanceof J.NewClass)) {
@@ -77,7 +78,13 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations v
                     maybeRemoveImport((JavaType.FullyQualified) vd.getType());
                 }
 
-                return DeclarationCheck.transformToVar(vd, (J.NewClass nc) -> maybeTransferTypeArguments(vd, nc));
+                if (initializer != originalInitializer) {
+                    Expression unwrapped = initializer.withPrefix(originalInitializer.getPrefix());
+                    vd = vd.withVariables(ListUtils.mapFirst(vd.getVariables(), nv -> nv.withInitializer(unwrapped)));
+                }
+
+                J.VariableDeclarations finalVd = vd;
+                return DeclarationCheck.transformToVar(vd, (J.NewClass nc) -> maybeTransferTypeArguments(finalVd, nc));
             }
 
             private J.NewClass maybeTransferTypeArguments(J.VariableDeclarations vd, J.NewClass initializer) {

src/main/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericMethodInvocations.java

@@ -66,15 +66,15 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations v
             }
 
             // Now we deal with generics, check for method invocations
-            Expression initializer = vd.getVariables().get(0).getInitializer();
-            boolean isMethodInvocation = initializer != null && initializer.unwrap() instanceof J.MethodInvocation;
-            if (!isMethodInvocation) {
+            Expression originalInitializer = vd.getVariables().get(0).getInitializer();
+            if (originalInitializer == null || !(originalInitializer.unwrap() instanceof J.MethodInvocation)) {
                 return vd;
             }
+            J.MethodInvocation invocation = (J.MethodInvocation) originalInitializer.unwrap();
 
             // If no type parameters and no arguments are present, we assume the type is too hard to determine
-            boolean hasNoTypeParams = ((J.MethodInvocation) initializer).getTypeParameters() == null;
-            boolean argumentsEmpty = allArgumentsEmpty((J.MethodInvocation) initializer);
+            boolean hasNoTypeParams = invocation.getTypeParameters() == null;
+            boolean argumentsEmpty = allArgumentsEmpty(invocation);
             if (hasNoTypeParams && argumentsEmpty) {
                 return vd;
             }
@@ -83,6 +83,11 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations v
                 maybeRemoveImport((JavaType.FullyQualified) vd.getType());
             }
 
+            if (invocation != originalInitializer) {
+                J.MethodInvocation unwrapped = invocation.withPrefix(originalInitializer.getPrefix());
+                vd = vd.withVariables(ListUtils.mapFirst(vd.getVariables(), nv -> nv.withInitializer(unwrapped)));
+            }
+
             // Make nested generic types explicit before converting to var
             J.VariableDeclarations finalVd = vd;
             return DeclarationCheck.transformToVar(vd, (J.MethodInvocation mi) -> makeNestedGenericsExplicit(mi, finalVd));

src/test/java/org/openrewrite/java/migrate/lang/var/UseVarForConstructorsTest.java

@@ -184,6 +184,33 @@ void test() {
         );
     }
 
+    @Test
+    void parenthesizedConstructorInitializer() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import java.util.ArrayList;
+
+              class A {
+                  void m() {
+                      ArrayList<String> list = (new ArrayList<String>());
+                  }
+              }
+              """,
+            """
+              import java.util.ArrayList;
+
+              class A {
+                  void m() {
+                      var list = new ArrayList<String>();
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @Test
     void doNotReplaceInvalidPatterns() {
         rewriteRun(

src/test/java/org/openrewrite/java/migrate/lang/var/UseVarForGenericMethodInvocationsTest.java

@@ -395,6 +395,36 @@ void m() {
             );
         }
 
+        @Test
+        void parenthesizedMethodInvocationInitializer() {
+            //language=java
+            rewriteRun(
+              version(
+                java(
+                  """
+                    import java.util.List;
+
+                    class A {
+                      void m() {
+                          List<String> strs = (List.of("one", "two"));
+                      }
+                    }
+                    """,
+                  """
+                    import java.util.List;
+
+                    class A {
+                      void m() {
+                          var strs = List.of("one", "two");
+                      }
+                    }
+                    """
+                ),
+                10
+              )
+            );
+        }
+
         @Issue("https://github.com/openrewrite/rewrite-migrate-java/issues/868")
         @Test
         void genericsCollectorsRegression() {