From b9dd2f736a6705bf78cb5d8e8f24cdd2c4d36563 Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Mon, 8 May 2023 13:25:33 +0200 Subject: [PATCH] [LL FIR] avoid redundant recursive type resolve for type aliases In LL FIR we will do this by crawlSupertype ^KT-56550 --- .../LLFirSupertypeLazyResolver.kt | 16 +- .../testdata/lazyResolve/nestedTypeAlias.kt | 7 + .../testdata/lazyResolve/nestedTypeAlias.txt | 433 ++++++++++++++++++ .../testdata/lazyResolve/nestedTypeAlias2.kt | 6 + .../testdata/lazyResolve/nestedTypeAlias2.txt | 279 +++++++++++ ...otLazyDeclarationResolveTestGenerated.java | 12 + ...ceLazyDeclarationResolveTestGenerated.java | 12 + .../transformers/FirSupertypesResolution.kt | 30 +- 8 files changed, 781 insertions(+), 14 deletions(-) create mode 100644 analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.kt create mode 100644 analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.txt create mode 100644 analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.kt create mode 100644 analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.txt diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt index a3e606c1254..6e418532fdb 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt +++ b/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 { val expandedTypeRef = expandedTypeRef - return supertypeResolver.resolveTypeAliasSupertype(this, expandedTypeRef) + return supertypeResolver.resolveTypeAliasSupertype(this, expandedTypeRef, resolveRecursively = false) } private inline fun 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 diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.kt b/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.kt new file mode 100644 index 00000000000..2c713ac5126 --- /dev/null +++ b/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.kt @@ -0,0 +1,7 @@ +class OuterClass : SuperForOuter() { + class NestedClass : Another() + typealias NestedType = NestedClass +} + +open class Another +open class SuperForOuter \ No newline at end of file diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.txt b/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias.txt new file mode 100644 index 00000000000..971f6523a1b --- /dev/null +++ b/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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass + + } + public? open [ResolvedTo(RAW_FIR)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public? open [ResolvedTo(RAW_FIR)] class SuperForOuter : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass + + } + public? open [ResolvedTo(RAW_FIR)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public? open [ResolvedTo(RAW_FIR)] class SuperForOuter : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] typealias NestedType<[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T> = NestedClass + + } + public? open [ResolvedTo(RAW_FIR)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public? open [ResolvedTo(RAW_FIR)] class SuperForOuter : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(COMPANION_GENERATION)] typealias NestedType<[ResolvedTo(COMPANION_GENERATION)] T> = NestedClass + + } + public? open [ResolvedTo(RAW_FIR)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public? open [ResolvedTo(RAW_FIR)] class SuperForOuter : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public? open [ResolvedTo(SUPER_TYPES)] class SuperForOuter : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(TYPES)] typealias NestedType<[ResolvedTo(TYPES)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public? open [ResolvedTo(SUPER_TYPES)] class SuperForOuter : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public final [ResolvedTo(STATUS)] typealias NestedType<[ResolvedTo(STATUS)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| { + public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] typealias NestedType<[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| { + public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] typealias NestedType<[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| { + public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public final [ResolvedTo(CONTRACTS)] typealias NestedType<[ResolvedTo(CONTRACTS)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| { + public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] typealias NestedType<[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| { + public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] typealias NestedType<[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| { + public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public final [ResolvedTo(BODY_RESOLVE)] typealias NestedType<[ResolvedTo(BODY_RESOLVE)] T> = R|OuterClass.NestedClass| + + } + public? open [ResolvedTo(SUPER_TYPES)] class Another : R|kotlin/Any| { + public? [ResolvedTo(RAW_FIR)] [ContainingClassKey=Another] constructor(): R|Another| { + LAZY_super + } + + } + public open [ResolvedTo(STATUS)] class SuperForOuter : R|kotlin/Any| { + public [ResolvedTo(STATUS)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + LAZY_super + } + + } + +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| { + super() + } + + 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| { + super() + } + + } + + public final [ResolvedTo(BODY_RESOLVE)] typealias NestedType<[ResolvedTo(BODY_RESOLVE)] T> = R|OuterClass.NestedClass| + + } + public open [ResolvedTo(BODY_RESOLVE)] class Another : R|kotlin/Any| { + public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=Another] constructor(): R|Another| { + super() + } + + } + public open [ResolvedTo(BODY_RESOLVE)] class SuperForOuter : R|kotlin/Any| { + public [ResolvedTo(BODY_RESOLVE)] [ContainingClassKey=SuperForOuter] constructor(): R|SuperForOuter| { + super() + } + + } diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.kt b/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.kt new file mode 100644 index 00000000000..ec33a2bb0cd --- /dev/null +++ b/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.kt @@ -0,0 +1,6 @@ +class OuterClass { + class NestedClass + typealias NestedType = NestedClass +} + +typealias ON3 = OuterClass.NestedType \ No newline at end of file diff --git a/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.txt b/analysis/low-level-api-fir/testdata/lazyResolve/nestedTypeAlias2.txt new file mode 100644 index 00000000000..de44ec94870 --- /dev/null +++ b/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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass + + } + public? final [ResolvedTo(RAW_FIR)] typealias ON3<[ResolvedTo(RAW_FIR)] T2> = OuterClass.NestedType + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass + + } + public? final [ResolvedTo(RAW_FIR)] typealias ON3<[ResolvedTo(RAW_FIR)] T2> = OuterClass.NestedType + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass + + } + public? final [ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] typealias ON3<[ResolvedTo(COMPILER_REQUIRED_ANNOTATIONS)] T2> = OuterClass.NestedType + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(RAW_FIR)] typealias NestedType<[ResolvedTo(RAW_FIR)] T> = NestedClass + + } + public? final [ResolvedTo(COMPANION_GENERATION)] typealias ON3<[ResolvedTo(COMPANION_GENERATION)] T2> = OuterClass.NestedType + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public? final [ResolvedTo(SUPER_TYPES)] typealias ON3<[ResolvedTo(SUPER_TYPES)] T2> = R|OuterClass.NestedType| + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public? final [ResolvedTo(TYPES)] typealias ON3<[ResolvedTo(TYPES)] T2> = R|OuterClass.NestedType| + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public final [ResolvedTo(STATUS)] typealias ON3<[ResolvedTo(STATUS)] T2> = R|OuterClass.NestedType| + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public final [ResolvedTo(EXPECT_ACTUAL_MATCHING)] typealias ON3<[ResolvedTo(EXPECT_ACTUAL_MATCHING)] T2> = R|OuterClass.NestedType| + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public final [ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] typealias ON3<[ResolvedTo(ARGUMENTS_OF_ANNOTATIONS)] T2> = R|OuterClass.NestedType| + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public final [ResolvedTo(CONTRACTS)] typealias ON3<[ResolvedTo(CONTRACTS)] T2> = R|OuterClass.NestedType| + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public final [ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] typealias ON3<[ResolvedTo(IMPLICIT_TYPES_BODY_RESOLVE)] T2> = R|OuterClass.NestedType| + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public final [ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] typealias ON3<[ResolvedTo(ANNOTATIONS_ARGUMENTS_MAPPING)] T2> = R|OuterClass.NestedType| + +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| { + LAZY_super + } + + 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| { + LAZY_super + } + + } + + public? final [ResolvedTo(SUPER_TYPES)] typealias NestedType<[ResolvedTo(SUPER_TYPES)] T> = R|OuterClass.NestedClass| + + } + public final [ResolvedTo(BODY_RESOLVE)] typealias ON3<[ResolvedTo(BODY_RESOLVE)] T2> = R|OuterClass.NestedType| + +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| { + super() + } + + 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| { + super() + } + + } + + public final [ResolvedTo(BODY_RESOLVE)] typealias NestedType<[ResolvedTo(BODY_RESOLVE)] T> = R|OuterClass.NestedClass| + + } + public final [ResolvedTo(BODY_RESOLVE)] typealias ON3<[ResolvedTo(BODY_RESOLVE)] T2> = R|OuterClass.NestedType| diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java index 28fbe7c710a..3a9fc2eeb4c 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirOutOfContentRootLazyDeclarationResolveTestGenerated.java +++ b/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 { diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java index 6d57904bc74..50ffe040137 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/FirSourceLazyDeclarationResolveTestGenerated.java +++ b/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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt index 54217969b40..31585887c15 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt +++ b/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 { + fun resolveTypeAliasSupertype( + typeAlias: FirTypeAlias, + expandedTypeRef: FirTypeRef, + resolveRecursively: Boolean, + ): List { // 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 (type is ConeClassLikeType) { - val symbol = type.lookupTag.toSymbol(session) - if (symbol is FirTypeAliasSymbol) { - visitTypeAlias(symbol.fir, null) - } else if (symbol is FirClassLikeSymbol) { - for (typeArgument in type.typeArguments) { - visitNestedTypeAliases(typeArgument) + if (resolveRecursively) { + fun visitNestedTypeAliases(type: TypeArgumentMarker) { + if (type is ConeClassLikeType) { + val symbol = type.lookupTag.toSymbol(session) + if (symbol is FirTypeAliasSymbol) { + visitTypeAlias(symbol.fir, null) + } else if (symbol is FirClassLikeSymbol) { + for (typeArgument in type.typeArguments) { + visitNestedTypeAliases(typeArgument) + } } } } - } - visitNestedTypeAliases(resolvedTypeRef.type) + visitNestedTypeAliases(resolvedTypeRef.type) + } listOf(resolvedTypeRef) }