FIR: make deeper recursive type alias expansion check (see KT-37000)

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerFirTestdataTestGenerated.java

@@ -452,6 +452,12 @@ public class DiagnosisCompilerFirTestdataTestGenerated extends AbstractDiagnosis
             runTest("compiler/fir/analysis-tests/testData/resolve/recursiveCallOnWhenWithSealedClass.kt");
         }
 
+        @Test
+        @TestMetadata("recursiveTypeAlias.kt")
+        public void testRecursiveTypeAlias() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/recursiveTypeAlias.kt");
+        }
+
         @Test
         @TestMetadata("sealedClass.kt")
         public void testSealedClass() throws Exception {

compiler/fir/analysis-tests/legacy-fir-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java

@@ -384,6 +384,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         runTest("compiler/fir/analysis-tests/testData/resolve/recursiveCallOnWhenWithSealedClass.kt");
     }
 
+    @TestMetadata("recursiveTypeAlias.kt")
+    public void testRecursiveTypeAlias() throws Exception {
+        runTest("compiler/fir/analysis-tests/testData/resolve/recursiveTypeAlias.kt");
+    }
+
     @TestMetadata("sealedClass.kt")
     public void testSealedClass() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/sealedClass.kt");

compiler/fir/analysis-tests/testData/resolve/recursiveTypeAlias.fir.txt

@@ -0,0 +1,4 @@
+FILE: recursiveTypeAlias.kt
+    public abstract interface Something<D, T : R|() -> Something1<D>|> : R|kotlin/Any| {
+    }
+    public final typealias Something1<D> = <ERROR TYPE REF: Loop in supertype: /Something1 -> /Something>

compiler/fir/analysis-tests/testData/resolve/recursiveTypeAlias.kt

@@ -0,0 +1,2 @@
+interface Something<D, T : () -> Something1<D>>
+typealias Something1<D> = <!RECURSIVE_TYPEALIAS_EXPANSION!>Something<D, () -> Something1<D>><!>

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java

@@ -452,6 +452,12 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest {
             runTest("compiler/fir/analysis-tests/testData/resolve/recursiveCallOnWhenWithSealedClass.kt");
         }
 
+        @Test
+        @TestMetadata("recursiveTypeAlias.kt")
+        public void testRecursiveTypeAlias() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/recursiveTypeAlias.kt");
+        }
+
         @Test
         @TestMetadata("sealedClass.kt")
         public void testSealedClass() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java

@@ -452,6 +452,12 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
             runTest("compiler/fir/analysis-tests/testData/resolve/recursiveCallOnWhenWithSealedClass.kt");
         }
 
+        @Test
+        @TestMetadata("recursiveTypeAlias.kt")
+        public void testRecursiveTypeAlias() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/recursiveTypeAlias.kt");
+        }
+
         @Test
         @TestMetadata("sealedClass.kt")
         public void testSealedClass() throws Exception {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -590,11 +590,18 @@ class SupertypeComputationSession {
                 checkIsInLoop(supertypeFir)
 
                 if (isTypeAlias) {
-                    for (typeArgument in supertypeRef.type.typeArguments) {
+                    fun checkTypeArgumentsRecursively(type: ConeKotlinType, visitedTypes: MutableSet<ConeKotlinType>) {
-                        if (typeArgument is ConeClassLikeType) {
+                        if (type in visitedTypes) return
-                            checkIsInLoop(typeArgument.lookupTag.toSymbol(session)?.fir)
+                        visitedTypes += type
+                        for (typeArgument in type.typeArguments) {
+                            if (typeArgument is ConeClassLikeType) {
+                                checkIsInLoop(typeArgument.lookupTag.toSymbol(session)?.fir)
+                                checkTypeArgumentsRecursively(typeArgument, visitedTypes)
+                            }
                         }
                     }
+
+                    checkTypeArgumentsRecursively(supertypeRef.type, mutableSetOf())
                 }
 
                 resultSupertypeRefs.add(