[LL FIR] avoid redundant recursive type resolve for type aliases

In LL FIR we will do this by crawlSupertype

^KT-56550

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt

@@ -141,7 +141,7 @@ private class LLFirSuperTypeTargetResolver(
 
     private fun FirTypeAlias.resolveExpandedTypeRef(): List<FirResolvedTypeRef> {
         val expandedTypeRef = expandedTypeRef
-        return supertypeResolver.resolveTypeAliasSupertype(this, expandedTypeRef)
+        return supertypeResolver.resolveTypeAliasSupertype(this, expandedTypeRef, resolveRecursively = false)
     }
 
     private inline fun <T : FirClassLikeDeclaration> performResolve(
@@ -245,10 +245,11 @@ private fun FirClassLikeDeclaration.canHaveLoopInSupertypesHierarchy(
 
     // We should still process resolved if it has loop in super type refs, because we can be part of this cycle
     !forceSkipResolvedClasses && this is FirRegularClass -> hasLoopInSupertypeRefs(session)
+    !forceSkipResolvedClasses && this is FirTypeAlias -> hasLoopInSupertypeRefs(session)
     else -> false
 }
 
-private fun FirRegularClass.outerClass(session: FirSession): FirRegularClass? = symbol.classId.parentClassId?.let { parentClassId ->
+private fun FirClassLikeDeclaration.outerClass(session: FirSession): FirRegularClass? = symbol.classId.parentClassId?.let { parentClassId ->
     session.symbolProvider.getClassLikeSymbolByClassId(parentClassId)?.fir as? FirRegularClass
 }
 
@@ -263,6 +264,17 @@ private fun FirRegularClass.hasLoopInSupertypeRefs(session: FirSession): Boolean
     return outerClass(session)?.hasLoopInSupertypeRefs(session) == true
 }
 
+/**
+ * The typealias must be already resolved
+ */
+private fun FirTypeAlias.hasLoopInSupertypeRefs(session: FirSession): Boolean {
+    if (expandedTypeRef.isLoopedSupertypeRef) {
+        return true
+    }
+
+    return outerClass(session)?.hasLoopInSupertypeRefs(session) == true
+}
+
 private val FirTypeRef.isLoopedSupertypeRef: Boolean
     get() {
         if (this !is FirErrorTypeRef) return false

analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.kt

@@ -0,0 +1,7 @@
+class OuterClass<T1> : SuperForOuter() {
+    class NestedClass<T2> : Another()
+    typealias Nes<caret>tedType<T> = NestedClass<T>
+}
+
+open class Another
+open class SuperForOuter

analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.txt

@@ -0,0 +1,433 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class OuterClass<[ResolvedTo(RAW_FIR)] T1> : SuperForOuter {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(RAW_FIR)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<SuperForOuter>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class NestedClass<[ResolvedTo(RAW_FIR)] T2> : Another {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(RAW_FIR)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass<T>
+
+    }
+    public? open [ResolvedTo(RAW_FIR)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? open [ResolvedTo(RAW_FIR)] class SuperForOuter : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class OuterClass<[ResolvedTo(RAW_FIR)] T1> : SuperForOuter {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(RAW_FIR)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<SuperForOuter>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class NestedClass<[ResolvedTo(RAW_FIR)] T2> : Another {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(RAW_FIR)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass<T>
+
+    }
+    public? open [ResolvedTo(RAW_FIR)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? open [ResolvedTo(RAW_FIR)] class SuperForOuter : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class OuterClass<[ResolvedTo(RAW_FIR)] T1> : SuperForOuter {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(RAW_FIR)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<SuperForOuter>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class NestedClass<[ResolvedTo(RAW_FIR)] T2> : Another {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(RAW_FIR)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public? final [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] typealias NestedType<[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T> = NestedClass<T>
+
+    }
+    public? open [ResolvedTo(RAW_FIR)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? open [ResolvedTo(RAW_FIR)] class SuperForOuter : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class OuterClass<[ResolvedTo(RAW_FIR)] T1> : SuperForOuter {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(RAW_FIR)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<SuperForOuter>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class NestedClass<[ResolvedTo(RAW_FIR)] T2> : Another {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(RAW_FIR)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public? final [ResolvedTo(COMPANION_GENERATION)] typealias NestedType<[ResolvedTo(COMPANION_GENERATION)] T> = NestedClass<T>
+
+    }
+    public? open [ResolvedTo(RAW_FIR)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? open [ResolvedTo(RAW_FIR)] class SuperForOuter : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|SuperForOuter| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<SuperForOuter>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class SuperForOuter : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(TYPES)] class OuterClass<[ResolvedTo(TYPES)] T1> : R|SuperForOuter| {
+        public? [ResolvedTo(TYPES)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|SuperForOuter|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public? final [ResolvedTo(TYPES)] typealias NestedType<[ResolvedTo(TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class SuperForOuter : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class OuterClass<[ResolvedTo(STATUS)] T1> : R|SuperForOuter| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(STATUS)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|SuperForOuter|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public final [ResolvedTo(STATUS)] typealias NestedType<[ResolvedTo(STATUS)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class OuterClass<[ResolvedTo(STATUS)] T1> : R|SuperForOuter| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(STATUS)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|SuperForOuter|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] typealias NestedType<[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class OuterClass<[ResolvedTo(STATUS)] T1> : R|SuperForOuter| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(STATUS)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|SuperForOuter|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] typealias NestedType<[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class OuterClass<[ResolvedTo(STATUS)] T1> : R|SuperForOuter| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(STATUS)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|SuperForOuter|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public final [ResolvedTo(CONTRACTS)] typealias NestedType<[ResolvedTo(CONTRACTS)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class OuterClass<[ResolvedTo(STATUS)] T1> : R|SuperForOuter| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(STATUS)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|SuperForOuter|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] typealias NestedType<[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class OuterClass<[ResolvedTo(STATUS)] T1> : R|SuperForOuter| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(STATUS)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|SuperForOuter|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] typealias NestedType<[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public final [ResolvedTo(STATUS)] class OuterClass<[ResolvedTo(STATUS)] T1> : R|SuperForOuter| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(STATUS)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|SuperForOuter|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|Another| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<Another>
+            }
+
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] typealias NestedType<[ResolvedTo(BODY_RESOLVE)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+    public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| {
+        public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+    }
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class OuterClass<[ResolvedTo(BODY_RESOLVE)] T1> : R|SuperForOuter| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(BODY_RESOLVE)] T1>(): R|OuterClass<T1>| {
+            super<R|SuperForOuter|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class NestedClass<[ResolvedTo(BODY_RESOLVE)] T2> : R|Another| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(BODY_RESOLVE)] T2>(): R|OuterClass.NestedClass<T2>| {
+                super<R|Another|>()
+            }
+
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] typealias NestedType<[ResolvedTo(BODY_RESOLVE)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public open [ResolvedTo(BODY_RESOLVE)] class Another : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Another] constructor(): R|Another| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public open [ResolvedTo(BODY_RESOLVE)] class SuperForOuter : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| {
+            super<R|kotlin/Any|>()
+        }
+
+    }

analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.kt

@@ -0,0 +1,6 @@
+class OuterClass<T1> {
+    class NestedClass<T2>
+    typealias NestedType<T> = NestedClass<T>
+}
+
+typealias ON<caret>3<T2> = OuterClass.NestedType<T2>

analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.txt

@@ -0,0 +1,279 @@
+RAW_FIR:
+FILE: [ResolvedTo(RAW_FIR)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class OuterClass<[ResolvedTo(RAW_FIR)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(RAW_FIR)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class NestedClass<[ResolvedTo(RAW_FIR)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(RAW_FIR)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass<T>
+
+    }
+    public? final [ResolvedTo(RAW_FIR)] typealias ON3<[ResolvedTo(RAW_FIR)] T2> = OuterClass.NestedType<T2>
+
+IMPORTS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class OuterClass<[ResolvedTo(RAW_FIR)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(RAW_FIR)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class NestedClass<[ResolvedTo(RAW_FIR)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(RAW_FIR)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass<T>
+
+    }
+    public? final [ResolvedTo(RAW_FIR)] typealias ON3<[ResolvedTo(RAW_FIR)] T2> = OuterClass.NestedType<T2>
+
+COMPILER_REQUIRED_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class OuterClass<[ResolvedTo(RAW_FIR)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(RAW_FIR)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class NestedClass<[ResolvedTo(RAW_FIR)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(RAW_FIR)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass<T>
+
+    }
+    public? final [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] typealias ON3<[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T2> = OuterClass.NestedType<T2>
+
+COMPANION_GENERATION:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(RAW_FIR)] class OuterClass<[ResolvedTo(RAW_FIR)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(RAW_FIR)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(RAW_FIR)] class NestedClass<[ResolvedTo(RAW_FIR)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(RAW_FIR)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass<T>
+
+    }
+    public? final [ResolvedTo(COMPANION_GENERATION)] typealias ON3<[ResolvedTo(COMPANION_GENERATION)] T2> = OuterClass.NestedType<T2>
+
+SUPER_TYPES:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? final [ResolvedTo(SUPER_TYPES)] typealias ON3<[ResolvedTo(SUPER_TYPES)] T2> = R|OuterClass.NestedType<T2>|
+
+TYPES:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public? final [ResolvedTo(TYPES)] typealias ON3<[ResolvedTo(TYPES)] T2> = R|OuterClass.NestedType<T2>|
+
+STATUS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public final [ResolvedTo(STATUS)] typealias ON3<[ResolvedTo(STATUS)] T2> = R|OuterClass.NestedType<T2>|
+
+EXPECT_ACTUAL_MATCHING:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] typealias ON3<[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T2> = R|OuterClass.NestedType<T2>|
+
+ARGUMENTS_OF_ANNOTATIONS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] typealias ON3<[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T2> = R|OuterClass.NestedType<T2>|
+
+CONTRACTS:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public final [ResolvedTo(CONTRACTS)] typealias ON3<[ResolvedTo(CONTRACTS)] T2> = R|OuterClass.NestedType<T2>|
+
+IMPLICIT_TYPES_BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] typealias ON3<[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T2> = R|OuterClass.NestedType<T2>|
+
+ANNOTATIONS_ARGUMENTS_MAPPING:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] typealias ON3<[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T2> = R|OuterClass.NestedType<T2>|
+
+BODY_RESOLVE:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(RAW_FIR)] annotations container
+    public? final? [ResolvedTo(SUPER_TYPES)] class OuterClass<[ResolvedTo(SUPER_TYPES)] T1> : R|kotlin/Any| {
+        public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(SUPER_TYPES)] T1>(): R|OuterClass<T1>| {
+            LAZY_super<R|kotlin/Any|>
+        }
+
+        public? final? [ResolvedTo(SUPER_TYPES)] class NestedClass<[ResolvedTo(SUPER_TYPES)] T2> : R|kotlin/Any| {
+            public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(SUPER_TYPES)] T2>(): R|OuterClass.NestedClass<T2>| {
+                LAZY_super<R|kotlin/Any|>
+            }
+
+        }
+
+        public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public final [ResolvedTo(BODY_RESOLVE)] typealias ON3<[ResolvedTo(BODY_RESOLVE)] T2> = R|OuterClass.NestedType<T2>|
+
+FILE RAW TO BODY:
+FILE: [ResolvedTo(IMPORTS)] nestedTypeAlias2.kt
+    [ResolvedTo(BODY_RESOLVE)] annotations container
+    public final [ResolvedTo(BODY_RESOLVE)] class OuterClass<[ResolvedTo(BODY_RESOLVE)] T1> : R|kotlin/Any| {
+        public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=OuterClass] constructor<[ResolvedTo(BODY_RESOLVE)] T1>(): R|OuterClass<T1>| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] class NestedClass<[ResolvedTo(BODY_RESOLVE)] T2> : R|kotlin/Any| {
+            public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=NestedClass] constructor<[ResolvedTo(BODY_RESOLVE)] T2>(): R|OuterClass.NestedClass<T2>| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+        public final [ResolvedTo(BODY_RESOLVE)] typealias NestedType<[ResolvedTo(BODY_RESOLVE)] T> = R|OuterClass.NestedClass<T>|
+
+    }
+    public final [ResolvedTo(BODY_RESOLVE)] typealias ON3<[ResolvedTo(BODY_RESOLVE)] T2> = R|OuterClass.NestedType<T2>|

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java

@@ -204,6 +204,18 @@ public class FirOutOfContentRootLazyDeclarationResolveTestGenerated extends Abst
         runTest("analysis/low-level-api-fir/testdata/lazyResolve/localNestedClass.kt");
     }
 
+    @Test
+    @TestMetadata("nestedTypeAlias.kt")
+    public void testNestedTypeAlias() throws Exception {
+        runTest("analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.kt");
+    }
+
+    @Test
+    @TestMetadata("nestedTypeAlias2.kt")
+    public void testNestedTypeAlias2() throws Exception {
+        runTest("analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.kt");
+    }
+
     @Test
     @TestMetadata("parameterOfNonLocalSetter.kt")
     public void testParameterOfNonLocalSetter() throws Exception {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java

@@ -204,6 +204,18 @@ public class FirSourceLazyDeclarationResolveTestGenerated extends AbstractFirSou
         runTest("analysis/low-level-api-fir/testdata/lazyResolve/localNestedClass.kt");
     }
 
+    @Test
+    @TestMetadata("nestedTypeAlias.kt")
+    public void testNestedTypeAlias() throws Exception {
+        runTest("analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.kt");
+    }
+
+    @Test
+    @TestMetadata("nestedTypeAlias2.kt")
+    public void testNestedTypeAlias2() throws Exception {
+        runTest("analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.kt");
+    }
+
     @Test
     @TestMetadata("parameterOfNonLocalSetter.kt")
     public void testParameterOfNonLocalSetter() throws Exception {

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

@@ -501,10 +501,14 @@ open class FirSupertypeResolverVisitor(
     }
 
     override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Any?) {
-        resolveTypeAliasSupertype(typeAlias, typeAlias.expandedTypeRef)
+        resolveTypeAliasSupertype(typeAlias, typeAlias.expandedTypeRef, resolveRecursively = true)
     }
 
-    fun resolveTypeAliasSupertype(typeAlias: FirTypeAlias, expandedTypeRef: FirTypeRef): List<FirResolvedTypeRef> {
+    fun resolveTypeAliasSupertype(
+        typeAlias: FirTypeAlias,
+        expandedTypeRef: FirTypeRef,
+        resolveRecursively: Boolean,
+    ): List<FirResolvedTypeRef> {
         // TODO: this if is a temporary hack for built-in types (because we can't load file for them)
         if (expandedTypeRef is FirResolvedTypeRef) {
             return listOf(expandedTypeRef)
@@ -520,20 +524,22 @@ open class FirSupertypeResolverVisitor(
                     )
                 )
 
-            fun visitNestedTypeAliases(type: TypeArgumentMarker) {
+            if (resolveRecursively) {
-                if (type is ConeClassLikeType) {
+                fun visitNestedTypeAliases(type: TypeArgumentMarker) {
-                    val symbol = type.lookupTag.toSymbol(session)
+                    if (type is ConeClassLikeType) {
-                    if (symbol is FirTypeAliasSymbol) {
+                        val symbol = type.lookupTag.toSymbol(session)
-                        visitTypeAlias(symbol.fir, null)
+                        if (symbol is FirTypeAliasSymbol) {
-                    } else if (symbol is FirClassLikeSymbol) {
+                            visitTypeAlias(symbol.fir, null)
-                        for (typeArgument in type.typeArguments) {
+                        } else if (symbol is FirClassLikeSymbol) {
-                            visitNestedTypeAliases(typeArgument)
+                            for (typeArgument in type.typeArguments) {
+                                visitNestedTypeAliases(typeArgument)
+                            }
                         }
                     }
                 }
-            }
 
-            visitNestedTypeAliases(resolvedTypeRef.type)
+                visitNestedTypeAliases(resolvedTypeRef.type)
+            }
 
             listOf(resolvedTypeRef)
         }