From 95678a4d64001b0f9f85ebc9b38b63ad28f5d7f4 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Mon, 28 Jan 2019 17:11:02 +0300 Subject: [PATCH] Extract FirAbstractTreeTransformer and *WithSuperTypes --- .../FirAbstractTreeTransformer.kt | 18 ++++ ...irAbstractTreeTransformerWithSuperTypes.kt | 62 ++++++++++++++ .../FirImportResolveTransformer.kt | 3 +- .../FirStatusResolveTransformer.kt | 9 +- .../transformers/FirTypeResolveTransformer.kt | 85 ++++--------------- .../fir/scopes/impl/FirCompositeScope.kt | 6 +- 6 files changed, 103 insertions(+), 80 deletions(-) create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt create mode 100644 compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt new file mode 100644 index 00000000000..b7ee1d2bf4d --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformer.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.resolve.transformers + +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult +import org.jetbrains.kotlin.fir.visitors.FirTransformer +import org.jetbrains.kotlin.fir.visitors.compose + +abstract class FirAbstractTreeTransformer : FirTransformer() { + override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { + @Suppress("UNCHECKED_CAST") + return (element.transformChildren(this, data) as E).compose() + } +} \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt new file mode 100644 index 00000000000..184f74443c5 --- /dev/null +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirAbstractTreeTransformerWithSuperTypes.kt @@ -0,0 +1,62 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.resolve.transformers + +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope +import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.ConeClassSymbol +import org.jetbrains.kotlin.fir.symbols.ConeTypeAliasSymbol +import org.jetbrains.kotlin.fir.types.ConeAbbreviatedType +import org.jetbrains.kotlin.fir.types.ConeClassErrorType +import org.jetbrains.kotlin.fir.types.ConeClassLikeType + +abstract class FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority: Boolean) : FirAbstractTreeTransformer() { + protected var towerScope = FirCompositeScope(mutableListOf(), reversedPriority = reversedScopePriority) + + protected inline fun withScopeCleanup(crossinline l: () -> T): T { + val scopeBefore = towerScope + val scopes = towerScope.scopes + val sizeBefore = scopes.size + val result = l() + towerScope = scopeBefore + assert(scopes.size >= sizeBefore) + scopes.subList(sizeBefore + 1, scopes.size).clear() + return result + } + + protected fun lookupSuperTypes(klass: FirRegularClass): List { + return mutableListOf().also { klass.symbol.collectSuperTypes(it) } + } + + private tailrec fun ConeClassLikeType.computePartialExpansion(): ConeClassLikeType? { + return when (this) { + is ConeAbbreviatedType -> directExpansion.takeIf { it !is ConeClassErrorType }?.computePartialExpansion() + else -> return this + } + } + + private tailrec fun ConeClassLikeSymbol.collectSuperTypes(list: MutableList) { + when (this) { + is ConeClassSymbol -> { + val superClassType = + this.superTypes + .map { it.computePartialExpansion() } + .firstOrNull { + it !is ConeClassErrorType && (it?.symbol as? ConeClassSymbol)?.kind == ClassKind.CLASS + } ?: return + list += superClassType + superClassType.symbol.collectSuperTypes(list) + } + is ConeTypeAliasSymbol -> { + val expansion = expansionType?.computePartialExpansion() ?: return + expansion.symbol.collectSuperTypes(list) + } + else -> error("?!id:1") + } + } +} \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt index 4c52a57a5f8..a8d4db9f5ba 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirImportResolveTransformer.kt @@ -13,12 +13,11 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedImportImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedPackageStarImport import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult -import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.compose import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName -class FirImportResolveTransformer() : FirTransformer() { +class FirImportResolveTransformer() : FirAbstractTreeTransformer() { override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { return element.compose() } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index 633633928e6..0d917b48c78 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt @@ -9,19 +9,12 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility -import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult -import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.compose -class FirStatusResolveTransformer : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - @Suppress("UNCHECKED_CAST") - return (element.transformChildren(this, data) as E).compose() - } - +class FirStatusResolveTransformer : FirAbstractTreeTransformer() { private val declarationsWithStatuses = mutableListOf() private val classes = mutableListOf() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt index f4877b540f5..e55de71885f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers -import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall @@ -27,33 +26,20 @@ import org.jetbrains.kotlin.fir.visitors.compose open class FirTypeResolveTransformer( private val traversedClassifiers: Set = setOf() -) : FirTransformer() { - override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { - @Suppress("UNCHECKED_CAST") - return (element.transformChildren(this, data) as E).compose() - } - - lateinit var scope: FirCompositeScope - +) : FirAbstractTreeTransformerWithSuperTypes(reversedScopePriority = false) { override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult { val session = file.session - scope = FirCompositeScope( - mutableListOf( - // from high priority to low priority - FirExplicitSimpleImportingScope(file.imports, session), - FirSelfImportingScope(file.packageFqName, session), - FirDefaultSimpleImportingScope(session), - FirExplicitStarImportingScope(file.imports, session), - FirDefaultStarImportingScope(session) - ) + towerScope.scopes += listOf( + // from high priority to low priority + FirExplicitSimpleImportingScope(file.imports, session), + FirSelfImportingScope(file.packageFqName, session), + FirDefaultSimpleImportingScope(session), + FirExplicitStarImportingScope(file.imports, session), + FirDefaultStarImportingScope(session) ) return super.transformFile(file, data) } - private fun lookupSuperTypes(klass: FirRegularClass): List { - return mutableListOf().also { klass.symbol.collectSuperTypes(it) } - } - private fun resolveSuperTypesAndExpansions(element: FirMemberDeclaration) { try { element.transformChildren(SuperTypeResolver(traversedClassifiers + listOfNotNull(element)), null) @@ -70,13 +56,13 @@ open class FirTypeResolveTransformer( val firProvider = FirProvider.getInstance(regularClass.session) val classId = regularClass.symbol.classId - scope.scopes += FirNestedClassifierScope(classId, firProvider) + towerScope.scopes += FirNestedClassifierScope(classId, firProvider) val companionObjects = regularClass.declarations.filterIsInstance().filter { it.isCompanion } for (companionObject in companionObjects) { - scope.scopes += FirNestedClassifierScope(companionObject.symbol.classId, firProvider) + towerScope.scopes += FirNestedClassifierScope(companionObject.symbol.classId, firProvider) } - lookupSuperTypes(regularClass).mapTo(scope.scopes) { + lookupSuperTypes(regularClass).mapTo(towerScope.scopes) { val symbol = it.symbol if (symbol is FirBasedSymbol<*>) { FirNestedClassifierScope(symbol.classId, FirProvider.getInstance(symbol.fir.session)) @@ -100,7 +86,7 @@ open class FirTypeResolveTransformer( private inline fun FirMemberDeclaration.withTypeParametersScope(crossinline l: () -> T): T { - val scopes = scope.scopes + val scopes = towerScope.scopes if (typeParameters.isNotEmpty()) { scopes += FirMemberTypeParameterScope(this) } @@ -111,17 +97,6 @@ open class FirTypeResolveTransformer( return result } - private inline fun withScopeCleanup(crossinline l: () -> T): T { - val scopeBefore = scope - val scopes = scope.scopes - val sizeBefore = scopes.size - val result = l() - scope = scopeBefore - assert(scopes.size >= sizeBefore) - scopes.subList(sizeBefore + 1, scopes.size).clear() - return result - } - override fun transformProperty(property: FirProperty, data: Nothing?): CompositeTransformResult { return property.withTypeParametersScope { super.transformProperty(property, data) @@ -137,7 +112,7 @@ open class FirTypeResolveTransformer( override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult { val typeResolver = FirTypeResolver.getInstance(type.session) type.transformChildren(this, null) - return transformType(type, typeResolver.resolveType(type, scope, position = FirPosition.OTHER)) + return transformType(type, typeResolver.resolveType(type, towerScope, position = FirPosition.OTHER)) } override fun transformFunctionType(functionType: FirFunctionType, data: Nothing?): CompositeTransformResult { @@ -151,7 +126,7 @@ open class FirTypeResolveTransformer( functionType.receiverType, functionType.valueParameters as MutableList, functionType.returnType, - typeResolver.resolveType(functionType, scope, FirPosition.OTHER) + typeResolver.resolveType(functionType, towerScope, FirPosition.OTHER) ).compose() } @@ -230,7 +205,7 @@ open class FirTypeResolveTransformer( override fun transformType(type: FirType, data: Nothing?): CompositeTransformResult { val typeResolver = FirTypeResolver.getInstance(type.session) - val symbol = typeResolver.resolveToSymbol(type, scope, position = FirPosition.SUPER_TYPE_OR_EXPANSION) + val symbol = typeResolver.resolveToSymbol(type, towerScope, position = FirPosition.SUPER_TYPE_OR_EXPANSION) val myTransformer = this@FirTypeResolveTransformer if (symbol != null) { @@ -245,35 +220,7 @@ open class FirTypeResolveTransformer( type.transformChildren(myTransformer, null) - return myTransformer.transformType(type, typeResolver.resolveUserType(type, symbol, scope)) + return myTransformer.transformType(type, typeResolver.resolveUserType(type, symbol, towerScope)) } } - - private tailrec fun ConeClassLikeType.computePartialExpansion(): ConeClassLikeType? { - return when (this) { - is ConeAbbreviatedType -> directExpansion.takeIf { it !is ConeClassErrorType }?.computePartialExpansion() - else -> return this - } - } - - private tailrec fun ConeClassLikeSymbol.collectSuperTypes(list: MutableList) { - when (this) { - is ConeClassSymbol -> { - val superClassType = - this.superTypes - .map { it.computePartialExpansion() } - .firstOrNull { - it !is ConeClassErrorType && (it?.symbol as? ConeClassSymbol)?.kind == ClassKind.CLASS - } ?: return - list += superClassType - superClassType.symbol.collectSuperTypes(list) - } - is ConeTypeAliasSymbol -> { - val expansion = expansionType?.computePartialExpansion() ?: return - expansion.symbol.collectSuperTypes(list) - } - else -> error("?!id:1") - } - } - } \ No newline at end of file diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt index 5ceb356131d..4c06e68a12a 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirCompositeScope.kt @@ -11,12 +11,16 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeParameterScope import org.jetbrains.kotlin.fir.symbols.ConeSymbol import org.jetbrains.kotlin.name.Name -class FirCompositeScope(val scopes: MutableList) : FirScope { +class FirCompositeScope( + val scopes: MutableList, + private val reversedPriority: Boolean = false +) : FirScope { override fun processClassifiersByName( name: Name, position: FirPosition, processor: (ConeSymbol) -> Boolean ): Boolean { + val scopes = if (reversedPriority) scopes.asReversed() else scopes for (scope in scopes) { if (!position.allowTypeParameters && scope is FirTypeParameterScope) continue if (!scope.processClassifiersByName(name, position, processor)) {