azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR] Support resolve of local typealiases

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2021-04-01 14:10:47 +03:00
committed by TeamCityServer
parent 3cb17ac2f0
commit 66668b2294
19 changed files with 62 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt
+6 -6
View File
@@ -39,7 +39,7 @@ class FirStatusResolveProcessor(
}
}
fun <F : FirClass<F>> F.runStatusResolveForLocalClass(
fun <F : FirClassLikeDeclaration<F>> F.runStatusResolveForLocalClass(
session: FirSession,
scopeSession: ScopeSession,
scopesForLocalClass: List<FirScope>,
@@ -75,7 +75,7 @@ class FirStatusResolveTransformer(
session: FirSession,
scopeSession: ScopeSession,
statusComputationSession: StatusComputationSession,
designationMapForLocalClasses: Map<FirClass<*>, FirClass<*>?> = mapOf(),
designationMapForLocalClasses: Map<FirClassLikeDeclaration<*>, FirClassLikeDeclaration<*>?> = mapOf(),
scopeForLocalClass: FirScope? = null,
) : AbstractFirStatusResolveTransformer(
session,
@@ -117,9 +117,9 @@ private class FirDesignatedStatusResolveTransformer(
session: FirSession,
scopeSession: ScopeSession,
private val designation: Iterator<FirDeclaration>,
private val targetClass: FirClass<*>,
private val targetClass: FirClassLikeDeclaration<*>,
statusComputationSession: StatusComputationSession,
designationMapForLocalClasses: Map<FirClass<*>, FirClass<*>?>,
designationMapForLocalClasses: Map<FirClassLikeDeclaration<*>, FirClassLikeDeclaration<*>?>,
scopeForLocalClass: FirScope?,
) : AbstractFirStatusResolveTransformer(
session,
@@ -204,7 +204,7 @@ sealed class StatusComputationSession {
}
}
class ForLocalClassResolution(private val localClasses: Set<FirClass<*>>) : StatusComputationSession() {
class ForLocalClassResolution(private val localClasses: Set<FirClassLikeDeclaration<*>>) : StatusComputationSession() {
private val delegate = Regular()
override fun get(klass: FirClass<*>): StatusComputationStatus {
@@ -226,7 +226,7 @@ abstract class AbstractFirStatusResolveTransformer(
final override val session: FirSession,
val scopeSession: ScopeSession,
protected val statusComputationSession: StatusComputationSession,
protected val designationMapForLocalClasses: Map<FirClass<*>, FirClass<*>?>,
protected val designationMapForLocalClasses: Map<FirClassLikeDeclaration<*>, FirClassLikeDeclaration<*>?>,
private val scopeForLocalClass: FirScope?
) : FirAbstractTreeTransformer<FirResolvedDeclarationStatus?>(phase = FirResolvePhase.STATUS) {
private val classes = mutableListOf<FirClass<*>>()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt
+2 -5
View File
@@ -58,7 +58,7 @@ class FirSupertypeResolverTransformer(
}
}
fun <F : FirClass<F>> F.runSupertypeResolvePhaseForLocalClass(
fun <F : FirClassLikeDeclaration<F>> F.runSupertypeResolvePhaseForLocalClass(
session: FirSession,
scopeSession: ScopeSession,
currentScopeList: List<FirScope>,
@@ -223,9 +223,6 @@ private class FirSupertypeResolverVisitor(
val result = when {
classId.isLocal -> {
// Local type aliases are not supported
if (classLikeDeclaration !is FirClass<*>) return persistentListOf()
// Local classes should be treated specially and supplied with localClassesNavigationInfo, normally
// But it seems to be too strict to add an assertion here
if (localClassesNavigationInfo == null) return persistentListOf()
@@ -233,7 +230,7 @@ private class FirSupertypeResolverVisitor(
val parent = localClassesNavigationInfo.parentForClass[classLikeDeclaration]
when {
parent != null -> prepareScopeForNestedClasses(parent)
parent != null && parent is FirClass<*> -> prepareScopeForNestedClasses(parent)
else -> scopeForLocalClass ?: return persistentListOf()
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt
+1 -1
View File
@@ -26,7 +26,7 @@ class FirTypeResolveProcessor(
override val transformer = FirTypeResolveTransformer(session, scopeSession)
}
fun <F : FirClass<F>> F.runTypeResolvePhaseForLocalClass(
fun <F : FirClassLikeDeclaration<F>> F.runTypeResolvePhaseForLocalClass(
session: FirSession,
scopeSession: ScopeSession,
currentScopeList: List<FirScope>,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt
+2 -2
View File
@@ -42,7 +42,7 @@ import org.jetbrains.kotlin.name.Name
class BodyResolveContext(
val returnTypeCalculator: ReturnTypeCalculator,
val dataFlowAnalyzerContext: DataFlowAnalyzerContext<PersistentFlow>,
val targetedLocalClasses: Set<FirClass<*>> = emptySet(),
val targetedLocalClasses: Set<FirClassLikeDeclaration<*>> = emptySet(),
val outerLocalClassForNested: MutableMap<FirClassLikeSymbol<*>, FirClassLikeSymbol<*>> = mutableMapOf()
) {
val fileImportsScope: MutableList<FirScope> = mutableListOf()
@@ -316,7 +316,7 @@ class BodyResolveContext(
@OptIn(PrivateForInline::class)
fun createSnapshotForLocalClasses(
returnTypeCalculator: ReturnTypeCalculator,
targetedLocalClasses: Set<FirClass<*>>
targetedLocalClasses: Set<FirClassLikeDeclaration<*>>
): BodyResolveContext =
BodyResolveContext(returnTypeCalculator, dataFlowAnalyzerContext, targetedLocalClasses, outerLocalClassForNested).apply {
file = this@BodyResolveContext.file
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt
+4
View File
@@ -302,6 +302,10 @@ open class FirBodyResolveTransformer(
return declarationsTransformer.transformValueParameter(valueParameter, data)
}
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
return declarationsTransformer.transformTypeAlias(typeAlias, data)
}
// ------------------------------------- Control flow statements -------------------------------------
override fun transformWhileLoop(whileLoop: FirWhileLoop, data: ResolutionMode): CompositeTransformResult<FirStatement> {
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt
+10
View File
@@ -358,6 +358,16 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
return doTransformRegularClass(regularClass, data)
}
override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): CompositeTransformResult<FirDeclaration> {
if (typeAlias.isLocal && typeAlias !in context.targetedLocalClasses) {
return typeAlias.runAllPhasesForLocalClass(transformer, components, data).compose()
}
doTransformTypeParameters(typeAlias)
typeAlias.transformAnnotations(transformer, data)
typeAlias.transformExpandedTypeRef(transformer, data)
return typeAlias.compose()
}
private fun doTransformRegularClass(
regularClass: FirRegularClass,
data: ResolutionMode
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt
+2 -2
View File
@@ -56,7 +56,7 @@ class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSes
}
}
fun <F : FirClass<F>> F.runContractAndBodiesResolutionForLocalClass(
fun <F : FirClassLikeDeclaration<F>> F.runContractAndBodiesResolutionForLocalClass(
components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents,
resolutionMode: ResolutionMode,
localClassesNavigationInfo: LocalClassesNavigationInfo,
@@ -183,7 +183,7 @@ private class ReturnTypeCalculatorWithJump(
private val session: FirSession,
private val scopeSession: ScopeSession,
val implicitBodyResolveComputationSession: ImplicitBodyResolveComputationSession,
val designationMapForLocalClasses: Map<FirCallableMemberDeclaration<*>, List<FirClass<*>>> = mapOf(),
val designationMapForLocalClasses: Map<FirCallableMemberDeclaration<*>, List<FirClassLikeDeclaration<*>>> = mapOf(),
val createTransformer: (
designation: Iterator<FirElement>,
session: FirSession,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt
+9 -9
View File
@@ -15,18 +15,18 @@ import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
import org.jetbrains.kotlin.utils.keysToMap
class LocalClassesNavigationInfo(
val parentForClass: Map<FirClass<*>, FirClass<*>?>,
private val parentClassForFunction: Map<FirCallableMemberDeclaration<*>, FirClass<*>>,
val parentForClass: Map<FirClassLikeDeclaration<*>, FirClassLikeDeclaration<*>?>,
private val parentClassForFunction: Map<FirCallableMemberDeclaration<*>, FirClassLikeDeclaration<*>>,
val allMembers: List<FirSymbolOwner<*>>
) {
val designationMap: Map<FirCallableMemberDeclaration<*>, List<FirClass<*>>> by lazy {
val designationMap: Map<FirCallableMemberDeclaration<*>, List<FirClassLikeDeclaration<*>>> by lazy {
parentClassForFunction.keys.keysToMap {
pathForCallable(it)
}
}
private fun pathForCallable(callableMemberDeclaration: FirCallableMemberDeclaration<*>): List<FirClass<*>> {
val result = mutableListOf<FirClass<*>>()
private fun pathForCallable(callableMemberDeclaration: FirCallableMemberDeclaration<*>): List<FirClassLikeDeclaration<*>> {
val result = mutableListOf<FirClassLikeDeclaration<*>>()
var current = parentClassForFunction[callableMemberDeclaration]
while (current != null) {
@@ -38,7 +38,7 @@ class LocalClassesNavigationInfo(
}
}
fun FirClass<*>.collectLocalClassesNavigationInfo(): LocalClassesNavigationInfo =
fun FirClassLikeDeclaration<*>.collectLocalClassesNavigationInfo(): LocalClassesNavigationInfo =
NavigationInfoVisitor().run {
this@collectLocalClassesNavigationInfo.accept(this@run)
@@ -46,10 +46,10 @@ fun FirClass<*>.collectLocalClassesNavigationInfo(): LocalClassesNavigationInfo
}
private class NavigationInfoVisitor : FirDefaultVisitorVoid() {
val resultingMap: MutableMap<FirCallableMemberDeclaration<*>, FirClass<*>> = mutableMapOf()
val parentForClass: MutableMap<FirClass<*>, FirClass<*>?> = mutableMapOf()
val resultingMap: MutableMap<FirCallableMemberDeclaration<*>, FirClassLikeDeclaration<*>> = mutableMapOf()
val parentForClass: MutableMap<FirClassLikeDeclaration<*>, FirClassLikeDeclaration<*>?> = mutableMapOf()
val allMembers: MutableList<FirSymbolOwner<*>> = mutableListOf()
private var currentPath: PersistentList<FirClass<*>> = persistentListOf()
private var currentPath: PersistentList<FirClassLikeDeclaration<*>> = persistentListOf()
override fun visitElement(element: FirElement) {}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt
+2 -2
View File
@@ -5,7 +5,7 @@
package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.runSupertypeResolvePhaseFor
import org.jetbrains.kotlin.fir.resolve.transformers.runTypeResolvePhaseForLocalClass
import org.jetbrains.kotlin.fir.scopes.impl.createCurrentScopeList
fun <F : FirClass<F>> F.runAllPhasesForLocalClass(
fun <F : FirClassLikeDeclaration<F>> F.runAllPhasesForLocalClass(
transformer: FirAbstractBodyResolveTransformer,
components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents,
resolutionMode: ResolutionMode
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt
+3 -2
View File
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers.contracts
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.resolve.ResolutionMode
@@ -39,11 +40,11 @@ class FirContractResolveTransformerAdapter(session: FirSession, scopeSession: Sc
}
}
fun <F : FirClass<F>> F.runContractResolveForLocalClass(
fun <F : FirClassLikeDeclaration<F>> F.runContractResolveForLocalClass(
session: FirSession,
scopeSession: ScopeSession,
outerBodyResolveContext: BodyResolveContext,
targetedClasses: Set<FirClass<*>>
targetedClasses: Set<FirClassLikeDeclaration<*>>
): F {
val newContext = outerBodyResolveContext.createSnapshotForLocalClasses(
ReturnTypeCalculatorForFullBodyResolve(),
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt
+2
View File
@@ -42,5 +42,7 @@ abstract class FirTypeAlias : FirPureAbstractElement(), FirClassLikeDeclaration<
abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirTypeAlias
abstract fun <D> transformExpandedTypeRef(transformer: FirTransformer<D>, data: D): FirTypeAlias
abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeAlias
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt
+6 -1
View File
@@ -51,7 +51,7 @@ internal class FirTypeAliasImpl(
override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirTypeAliasImpl {
transformStatus(transformer, data)
transformTypeParameters(transformer, data)
expandedTypeRef = expandedTypeRef.transformSingle(transformer, data)
transformExpandedTypeRef(transformer, data)
transformAnnotations(transformer, data)
return this
}
@@ -66,6 +66,11 @@ internal class FirTypeAliasImpl(
return this
}
override fun <D> transformExpandedTypeRef(transformer: FirTransformer<D>, data: D): FirTypeAliasImpl {
expandedTypeRef = expandedTypeRef.transformSingle(transformer, data)
return this
}
override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirTypeAliasImpl {
annotations.transformInplace(transformer, data)
return this
compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt
+1 -1
View File
@@ -92,7 +92,7 @@ inline val FirProperty.allowsToHaveFakeOverride: Boolean
inline val FirPropertyAccessor.allowsToHaveFakeOverride: Boolean
get() = !Visibilities.isPrivate(visibility) && visibility != Visibilities.InvisibleFake
inline val FirRegularClass.isLocal get() = symbol.classId.isLocal
inline val FirClassLikeDeclaration<*>.isLocal get() = symbol.classId.isLocal
inline val FirSimpleFunction.isLocal get() = status.visibility == Visibilities.Local
fun FirRegularClassBuilder.addDeclaration(declaration: FirDeclaration) {
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt
+1 -1
View File
@@ -271,7 +271,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
parentArg(classLikeDeclaration, "F", typeAlias)
+name
+symbol("FirTypeAliasSymbol")
+field("expandedTypeRef", typeRef, withReplace = true)
+field("expandedTypeRef", typeRef, withReplace = true).withTransform()
+annotations
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.fir.kt
Vendored
+2 -2
View File
@@ -10,7 +10,7 @@ private fun <E> foobar() = {
fun a() = A<E, X, Y, Z>()
}
typealias LocalAlias<W> = A<<!UNRESOLVED_REFERENCE!>E<!>, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, <!UNRESOLVED_REFERENCE!>W<!>>
typealias LocalAlias<W> = A<E, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, W>
}
class Derived : LocalOuter<Double, Short>() {
@@ -27,7 +27,7 @@ private fun noParameters() = {
fun a() = A<Any, X, Y, Z>()
}
typealias LocalAlias2<W> = A<<!UNRESOLVED_REFERENCE!>Any<!>, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, <!UNRESOLVED_REFERENCE!>W<!>>
typealias LocalAlias2<W> = A<Any, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, W>
}
class Derived2 : LocalOuter2<Double, Short>() {
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.fir.kt
Vendored
+2 -2
View File
@@ -12,7 +12,7 @@ class Outer<T> {
fun a() = A<T, F, E, X, Y, Z>()
}
typealias LocalAlias<W> = A<<!UNRESOLVED_REFERENCE!>T<!>, <!UNRESOLVED_REFERENCE!>F<!>, <!UNRESOLVED_REFERENCE!>E<!>, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, <!UNRESOLVED_REFERENCE!>W<!>>
typealias LocalAlias<W> = A<T, F, E, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, W>
}
class Derived : LocalOuter<Double, Short>() {
@@ -29,7 +29,7 @@ class Outer<T> {
fun a() = A<T, F, Any, X, Y, Z>()
}
typealias LocalAlias2<W> = A<<!UNRESOLVED_REFERENCE!>T<!>, <!UNRESOLVED_REFERENCE!>F<!>, <!UNRESOLVED_REFERENCE!>Any<!>, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, <!UNRESOLVED_REFERENCE!>W<!>>
typealias LocalAlias2<W> = A<T, F, Any, <!UNRESOLVED_REFERENCE!>X<!>, <!UNRESOLVED_REFERENCE!>Y<!>, W>
}
class Derived2 : LocalOuter2<Double, Short>() {
compiler/testData/diagnostics/tests/typealias/capturingTypeParametersFromOuterClass.fir.kt
Vendored
+4 -4
View File
@@ -17,13 +17,13 @@ class Outer<TO> {
fun <TF> foo() {
class Local<TL> {
typealias LTF = <!UNRESOLVED_REFERENCE!>List<<!UNRESOLVED_REFERENCE!>TF<!>><!>
typealias LTL = <!UNRESOLVED_REFERENCE!>List<<!UNRESOLVED_REFERENCE!>TL<!>><!>
typealias LTF = List<TF>
typealias LTL = List<<!UNRESOLVED_REFERENCE!>TL<!>>
}
fun <TLF> localfun() =
object {
typealias LTF = List<<!UNRESOLVED_REFERENCE!>TF<!>>
typealias LTLF = List<<!UNRESOLVED_REFERENCE!>TLF<!>>
typealias LTF = List<TF>
typealias LTLF = List<TLF>
}
}
compiler/testData/diagnostics/tests/typealias/localTypeAliasRecursive.fir.kt
Vendored
+2 -2
View File
@@ -3,5 +3,5 @@
fun outer() {
typealias Test1 = <!UNRESOLVED_REFERENCE!>Test1<!>
typealias Test2 = List<<!UNRESOLVED_REFERENCE!>Test2<!>>
typealias Test3<T> = List<<!UNRESOLVED_REFERENCE!>Test3<<!UNRESOLVED_REFERENCE!>T<!>><!>>
}
typealias Test3<T> = List<<!UNRESOLVED_REFERENCE!>Test3<T><!>>
}
compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.fir.kt
Vendored
+1 -1
View File
@@ -29,7 +29,7 @@ fun testWrong4(x: List<Any>) = x is <!NO_TYPE_ARGUMENTS_ON_RHS!>ReadableList<!>
fun <T> testLocal(x: Any) {
class C
typealias CA = C
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>CA<!> = C
if (x is C) {}
if (x is <!UNRESOLVED_REFERENCE!>CA<!>) {}
}