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

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;
+        }
+        AtomicBoolean reassigned = new AtomicBoolean(false);
+        new JavaIsoVisitor<AtomicBoolean>() {
+            @Override
+            public J.Assignment visitAssignment(J.Assignment assignment, AtomicBoolean found) {
+                if (!found.get() && assignment.getVariable() instanceof J.Identifier) {
+                    JavaType.Variable fieldType = ((J.Identifier) assignment.getVariable()).getFieldType();
+                    if (variableType.equals(fieldType)) {
+                        found.set(true);
+                    }
+                }
+                return super.visitAssignment(assignment, found);
+            }
+        }.visit(method, reassigned);
+        return reassigned.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/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