Fix StackoverflowError in Kotlin type processing

rewrite-java-tck/src/main/java/org/openrewrite/java/tree/TypeUtilsTest.java

@@ -1550,4 +1550,28 @@ void test() {
           )
         );
     }
+
+    @Issue("https://github.com/openrewrite/rewrite/issues/6140")
+    @Test
+    void isAssignableToWithCircularTypeReference() {
+        // Create a mock type with a circular supertype reference
+        JavaType.Class circularType = JavaType.ShallowClass.build("com.example.CircularType");
+        JavaType.Class withCircularSupertype = new JavaType.Class(
+            null,
+            0L,
+            "com.example.CircularType",
+            JavaType.Class.Kind.Class,
+            (JavaType[]) null, // typeParameters
+            circularType, // Set supertype to itself - this creates a cycle
+            null, // owningClass
+            (JavaType.FullyQualified[]) null, // annotations
+            (JavaType.FullyQualified[]) null, // interfaces
+            (JavaType.Variable[]) null, // members
+            (JavaType.Method[]) null  // methods
+        );
+        // This should not cause a StackOverflowError
+        assertFalse(TypeUtils.isAssignableTo("java.lang.String", withCircularSupertype));
+        // Even though it has itself as supertype, Object match should work
+        assertTrue(TypeUtils.isAssignableTo("java.lang.Object", withCircularSupertype));
+    }
 }

rewrite-java/src/main/java/org/openrewrite/java/tree/TypeUtils.java

@@ -804,8 +804,17 @@ private static boolean isPseudoType(@Nullable JavaType type) {
     }
 
     public static boolean isAssignableTo(String to, @Nullable JavaType from) {
+        return isAssignableTo(to, from, new HashSet<>());
+    }
+
+    private static boolean isAssignableTo(String to, @Nullable JavaType from, Set<JavaType> visited) {
         try {
             if (from instanceof JavaType.FullyQualified) {
+                // Prevent infinite recursion by tracking visited types
+                if (!visited.add(from)) {
+                    return false;
+                }
+
                 if (from instanceof JavaType.Parameterized) {
                     int lessThanIndex = to.indexOf('<');
                     String fromRawType = ((JavaType.Parameterized) from).getType().getFullyQualifiedName();
@@ -815,19 +824,19 @@ public static boolean isAssignableTo(String to, @Nullable JavaType from) {
                 }
                 JavaType.FullyQualified classFrom = (JavaType.FullyQualified) from;
                 if (fullyQualifiedNamesAreEqual(to, classFrom.getFullyQualifiedName()) ||
-                    isAssignableTo(to, classFrom.getSupertype())) {
+                    isAssignableTo(to, classFrom.getSupertype(), visited)) {
                     return true;
                 }
                 for (JavaType.FullyQualified i : classFrom.getInterfaces()) {
-                    if (isAssignableTo(to, i)) {
+                    if (isAssignableTo(to, i, visited)) {
                         return true;
                     }
                 }
                 return false;
             } else if (from instanceof JavaType.GenericTypeVariable) {
                 JavaType.GenericTypeVariable genericFrom = (JavaType.GenericTypeVariable) from;
                 for (JavaType bound : genericFrom.getBounds()) {
-                    if (isAssignableTo(to, bound)) {
+                    if (isAssignableTo(to, bound, visited)) {
                         return true;
                     }
                 }
@@ -839,12 +848,12 @@ public static boolean isAssignableTo(String to, @Nullable JavaType from) {
                     return isAssignableTo(JavaType.Primitive.String, from);
                 }
             } else if (from instanceof JavaType.Variable) {
-                return isAssignableTo(to, ((JavaType.Variable) from).getType());
+                return isAssignableTo(to, ((JavaType.Variable) from).getType(), visited);
             } else if (from instanceof JavaType.Method) {
-                return isAssignableTo(to, ((JavaType.Method) from).getReturnType());
+                return isAssignableTo(to, ((JavaType.Method) from).getReturnType(), visited);
             } else if (from instanceof JavaType.Intersection) {
                 for (JavaType bound : ((JavaType.Intersection) from).getBounds()) {
-                    if (isAssignableTo(to, bound)) {
+                    if (isAssignableTo(to, bound, visited)) {
                         return true;
                     }
                 }