Skip var when reassignment relies on declared supertype (#1078)

* Skip `var` when reassignment relies on declared supertype

When a generic variable is declared as a supertype but initialized with a
concrete subtype constructor or method, switching to `var` narrows the
inferred type and breaks later reassignments. Detect reassignment within
the enclosing method and skip the transformation in that case.

Fixes #1077

* Fix flaky `JohnzonJavaxtoJakartaTest` and use `.reduce` in var helper

The test's `2.1.\d+` regex matched `<johnzon.version>2.1.0</johnzon.version>`
before reaching the jakarta.json-api dependency, so when jakarta.json-api
was released as 2.1.3 the expected/actual diverged. Anchor the regex to
the jakarta.json-api artifact.

Also consolidate the `isReassigned` visitor to use `.reduce(...)` directly,
matching the existing idiom in NullCheck and other recipes.

Author: timtebeek

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

@@ -19,10 +19,12 @@
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.Cursor;
 import org.openrewrite.internal.ListUtils;
+import org.openrewrite.java.JavaIsoVisitor;
 import org.openrewrite.java.tree.*;
 import org.openrewrite.marker.Markers;
 
 import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.UnaryOperator;
 
 import static java.util.Collections.emptyList;
@@ -233,6 +235,41 @@ public static boolean initializedByStaticMethod(@Nullable Expression initializer
         return invocation.getMethodType().hasFlags(Flag.Static);
     }
 
+    /**
+     * Determine whether the variable declared in {@code vd} is later reassigned within the
+     * enclosing method. Reassignments matter when the declared type differs from the
+     * initializer's concrete type, since switching to {@code var} narrows the inferred type
+     * and may break subsequent assignments of supertype values.
+     *
+     * @param cursor location of the visitor
+     * @param vd     variable definition at hand
+     * @return true iff the variable is reassigned within the enclosing method
+     */
+    public static boolean isReassigned(Cursor cursor, J.VariableDeclarations vd) {
+        JavaType.Variable variableType = vd.getVariables().get(0).getVariableType();
+        if (variableType == null) {
+            return false;
+        }
+        J.MethodDeclaration method = cursor.firstEnclosing(J.MethodDeclaration.class);
+        if (method == null) {
+            return false;
+        }
+        return new JavaIsoVisitor<AtomicBoolean>() {
+            @Override
+            public J.Assignment visitAssignment(J.Assignment assignment, AtomicBoolean found) {
+                if (found.get()) {
+                    return assignment;
+                }
+                if (assignment.getVariable() instanceof J.Identifier &&
+                        variableType.equals(((J.Identifier) assignment.getVariable()).getFieldType())) {
+                    found.set(true);
+                    return assignment;
+                }
+                return super.visitAssignment(assignment, found);
+            }
+        }.reduce(method, new AtomicBoolean(false)).get();
+    }
+
     public static J.VariableDeclarations transformToVar(J.VariableDeclarations vd) {
         return transformToVar(vd, it -> it);
     }

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

@@ -79,6 +79,13 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations v
                 return vd;
             }
 
+            // Switching to var narrows the variable type to the initializer's concrete type, which can break later
+            // reassignments that rely on the declared (super)type. Skip when types differ and the variable is reassigned.
+            if (!TypeUtils.isOfType(vd.getType(), invocation.getType()) &&
+                    DeclarationCheck.isReassigned(getCursor(), vd)) {
+                return vd;
+            }
+
             if (vd.getType() instanceof JavaType.FullyQualified) {
                 maybeRemoveImport((JavaType.FullyQualified) vd.getType());
             }

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

@@ -27,6 +27,7 @@
 import org.openrewrite.java.tree.J;
 import org.openrewrite.java.tree.JavaType;
 import org.openrewrite.java.tree.TypeTree;
+import org.openrewrite.java.tree.TypeUtils;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -78,6 +79,14 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations v
                 return vd;
             }
 
+            // Switching to var narrows the variable type to the initializer's concrete type, which can break later
+            // reassignments that rely on the declared (super)type. Skip when types differ and the variable is reassigned.
+            Expression initializer = variable.getInitializer();
+            if (initializer != null && !TypeUtils.isOfType(vd.getType(), initializer.unwrap().getType()) &&
+                    DeclarationCheck.isReassigned(getCursor(), vd)) {
+                return vd;
+            }
+
             if (vd.getType() instanceof JavaType.FullyQualified) {
                 maybeRemoveImport((JavaType.FullyQualified) vd.getType());
             }

src/test/java/org/openrewrite/java/migrate/jakarta/JohnzonJavaxtoJakartaTest.java

@@ -68,7 +68,8 @@ void migrateJohnzonDependencies() {
                   Matcher version = Pattern.compile("<johnzon.version>([0-9]+\\.[0-9]+\\.[0-9]+)</johnzon.version>")
                     .matcher(actual);
 
-                  Matcher jsonApiVersion = Pattern.compile("2.1.\\d+").matcher(actual);
+                  Matcher jsonApiVersion = Pattern.compile("(?s)<artifactId>jakarta\\.json-api</artifactId>\\s*<version>(2\\.1\\.\\d+)</version>")
+                    .matcher(actual);
                   assertThat(jsonApiVersion.find()).describedAs("Expected jakarta.json-api 2.1.x version in %s", actual).isTrue();
 
                   assertThat(version.find()).isTrue();
@@ -94,7 +95,7 @@ void migrateJohnzonDependencies() {
                         </dependency>
                     </dependencies>
                 </project>
-                """.formatted(version.group(1), jsonApiVersion.group(0));
+                """.formatted(version.group(1), jsonApiVersion.group(1));
               })
             ),
             srcMainJava(

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

@@ -170,6 +170,33 @@ void m() {
             );
         }
 
+        @Issue("https://github.com/openrewrite/rewrite-migrate-java/issues/1077")
+        @Test
+        void reassignedToSupertype() {
+            //language=java
+            rewriteRun(
+              java(
+                """
+                  import java.util.HashSet;
+                  import java.util.Set;
+
+                  class A {
+                      Set<String> transfer(Set<String> in) {
+                          return in;
+                      }
+
+                      void m() {
+                          Set<String> currentFacts = new HashSet<>();
+                          for (int i = 0; i < 3; i++) {
+                              currentFacts = transfer(currentFacts);
+                          }
+                      }
+                  }
+                  """
+              )
+            );
+        }
+
         @Test
         void javaLowerThan10() {
             //language=java