Rename variables if the name matches class name

rewrite-java-test/src/test/java/org/openrewrite/java/ChangeTypeTest.java

@@ -1592,8 +1592,8 @@ public A1 method(A1 a1) {
               import a.A2;
 
               public class Example {
-                  public A2 method(A2 a1) {
-                      return a1;
+                  public A2 method(A2 a2) {
+                      return a2;
                   }
               }
               """
@@ -1630,6 +1630,92 @@ public class Test {
         );
     }
 
+    @Test
+    void updateMethodTypeWithUnicodeCharacter() {
+        rewriteRun(
+          spec -> spec.recipe(new ChangeType("a.Ą1", "a.Ą2", false)),
+          java(
+            """
+              package a;
+              public class Ą1 {
+              }
+              """,
+            """
+              package a;
+              public class Ą2 {
+              }
+              """
+          ),
+          java(
+            """
+              package org.foo;
+
+              import a.Ą1;
+
+              public class Example {
+                  public Ą1 method(Ą1 ą1) {
+                      return ą1;
+                  }
+              }
+              """,
+            """
+              package org.foo;
+
+              import a.Ą2;
+
+              public class Example {
+                  public Ą2 method(Ą2 ą2) {
+                      return ą2;
+                  }
+              }
+              """
+          )
+        );
+    }
+
+    @Test
+    void doNotRenameRandomVariablesMatchingClassName() {
+        rewriteRun(
+          spec -> spec.recipe(new ChangeType("a.A1", "a.A2", false)),
+          java(
+            """
+              package a;
+              public class A1 {
+              }
+              """,
+            """
+              package a;
+              public class A2 {
+              }
+              """
+          ),
+          java(
+            """
+              package org.foo;
+
+              import a.A1;
+
+              public class Example {
+                  public String method(A1 a, String a1) {
+                      return a1;
+                  }
+              }
+              """,
+            """
+              package org.foo;
+
+              import a.A2;
+
+              public class Example {
+                  public String method(A2 a, String a1) {
+                      return a1;
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @Test
     void updateVariableType() {
         rewriteRun(

rewrite-java/src/main/java/org/openrewrite/java/ChangeType.java

@@ -20,6 +20,7 @@
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.*;
 import org.openrewrite.internal.ListUtils;
+import org.openrewrite.java.VariableNameUtils.GenerationStrategy;
 import org.openrewrite.java.search.UsesType;
 import org.openrewrite.java.tree.*;
 import org.openrewrite.marker.Markers;
@@ -368,6 +369,23 @@ public J visitIdentifier(J.Identifier ident, ExecutionContext ctx) {
                     }
                 }
 
+                // Rename variable if it matches class name (starting with a lowercase character)
+                if (ident.getSimpleName().equals(decapitalize(className))) {
+                    if (targetType instanceof JavaType.FullyQualified) {
+                        String newName = VariableNameUtils.generateVariableName(
+                                decapitalize(((JavaType.FullyQualified) targetType).getClassName()),
+                                getCursor(),
+                                GenerationStrategy.INCREMENT_NUMBER
+                        );
+
+                        ident = ident.withSimpleName(newName);
+
+                        if (ident.getFieldType() != null) {
+                            ident = ident.withFieldType(ident.getFieldType().withName(newName));
+                        }
+                    }
+                }
+
                 // Recreate any static imports as needed
                 if (sf != null) {
                     for (J.Import anImport : sf.getImports()) {
@@ -387,6 +405,15 @@ public J visitIdentifier(J.Identifier ident, ExecutionContext ctx) {
             return visitAndCast(ident, ctx, super::visitIdentifier);
         }
 
+        @Override
+        public J.VariableDeclarations.NamedVariable visitVariable(J.VariableDeclarations.NamedVariable variable, ExecutionContext executionContext) {
+            J.VariableDeclarations.NamedVariable v = (J.VariableDeclarations.NamedVariable) super.visitVariable(variable, executionContext);
+            if (v.getVariableType() != null && !v.getSimpleName().equals(v.getVariableType().getName())) {
+                return v.withVariableType(v.getVariableType().withName(v.getSimpleName()));
+            }
+            return v;
+        }
+
         @Override
         public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
             if (method.getMethodType() != null && method.getMethodType().hasFlags(Flag.Static)) {
@@ -778,4 +805,19 @@ private static boolean hasSameFQN(J.Import import_, JavaType targetType) {
 
         return fqn != null && fqn.equals(curFqn);
     }
+
+    private static String decapitalize(String string) {
+        if (!string.isEmpty()) {
+            int firstCodePoint = string.codePointAt(0);
+            int firstCodePointLowercase = Character.toLowerCase(firstCodePoint);
+
+            if (firstCodePoint != firstCodePointLowercase) {
+                return new StringBuilder()
+                        .appendCodePoint(firstCodePointLowercase)
+                        .append(string.substring(Character.charCount(firstCodePoint)))
+                        .toString();
+            }
+        }
+        return string;
+    }
 }

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/ChangeTypeTest.java

@@ -195,7 +195,7 @@ fun test(original: Original<String>) { }
 
               import x.y.Target
 
-              fun test(original: Target<String>) { }
+              fun test(target: Target<String>) { }
               """
           )
         );
@@ -231,7 +231,7 @@ fun test(original: MyAlias<String>) { }
 
               import x.y.Target as MyAlias
 
-              fun test(original: MyAlias<String>) { }
+              fun test(target: MyAlias<String>) { }
               """
           )
         );
@@ -263,7 +263,7 @@ fun test(original: a.b.Original<String>) { }
 
               import x.y.Target
 
-              fun test(original: Target<String>) { }
+              fun test(target: Target<String>) { }
               """
           )
         );