From e817f919c2ca217004f15ca94e143f2a081b71d7 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Fri, 26 Jun 2020 14:59:37 +0300 Subject: [PATCH] [FIR] Cleanup FIR modules. Part 5 (`body.resolve` package) --- .../FirAbstractBodyResolveTransformer.kt | 2 -- ...ControlFlowStatementsResolveTransformer.kt | 8 +++-- .../FirDeclarationsResolveTransformer.kt | 3 +- .../FirExpressionsResolveTransformer.kt | 31 ++++++++++--------- .../body/resolve/FirImplicitBodyResolve.kt | 7 +++-- .../body/resolve/LocalClassesNavigation.kt | 11 ++++--- 6 files changed, 34 insertions(+), 28 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt index 399b4e15127..c77741adb8b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformer.kt @@ -94,7 +94,6 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb protected inline val integerLiteralTypeApproximator: IntegerLiteralTypeApproximationTransformer get() = components.integerLiteralTypeApproximator protected inline val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater get() = components.integerOperatorsTypeUpdater - val ResolutionMode.expectedType: FirTypeRef? get() = when (this) { is ResolutionMode.WithExpectedType -> expectedTypeRef @@ -294,4 +293,3 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb override val integerOperatorsTypeUpdater: IntegerOperatorsTypeUpdater = IntegerOperatorsTypeUpdater(integerLiteralTypeApproximator) } } - diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt index 592550026a7..4bee7cedb47 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt @@ -146,7 +146,8 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran dataFlowAnalyzer.exitTryMainBlock(tryExpression) tryExpression.transformCatches(this, ResolutionMode.ContextDependent) - var callCompleted: Boolean = false + var callCompleted = false + @Suppress("NAME_SHADOWING") var result = syntheticCallGenerator.generateCalleeForTryExpression(tryExpression)?.let { val expectedTypeRef = data.expectedType @@ -199,7 +200,10 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran return result.compose() } - override fun transformThrowExpression(throwExpression: FirThrowExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformThrowExpression( + throwExpression: FirThrowExpression, + data: ResolutionMode + ): CompositeTransformResult { return transformer.transformExpression(throwExpression, data).also { dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index 51006d8b12e..387db61ed40 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -661,7 +661,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor .mapNotNull { (it as? FirExpression)?.resultType?.coneTypeUnsafe() } af.replaceReturnTypeRef( af.returnTypeRef.resolvedTypeFromPrototype( - inferenceComponents.ctx.commonSuperTypeOrNull(returnTypes) ?: session.builtinTypes.unitType.coneTypeUnsafe() + inferenceComponents.ctx.commonSuperTypeOrNull(returnTypes) ?: session.builtinTypes.unitType.type ) ) af.replaceTypeRef(af.constructFunctionalTypeRef()) @@ -689,6 +689,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor it.bind(this@addReturn) } } + @Suppress("UNCHECKED_CAST") return (returnExpression as E).compose() } return element.compose() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 2733464ab51..232d1187291 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -45,18 +45,10 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform var enableArrayOfCallTransformation = false init { + @Suppress("LeakingThis") components.callResolver.initTransformer(this) } - private inline fun withFirArrayOfCallTransformer(block: () -> T): T { - enableArrayOfCallTransformation = true - return try { - block() - } finally { - enableArrayOfCallTransformation = false - } - } - override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult { if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) { val type = buildErrorTypeRef { @@ -242,7 +234,6 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform withNewLocalScope { transformBlockInCurrentScope(block, data) } - return block.compose() } @@ -444,7 +435,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform checkNotNullCall.argumentList.transformArguments(transformer, ResolutionMode.ContextDependent) - var callCompleted: Boolean = false + var callCompleted = false val result = components.syntheticCallGenerator.generateCalleeForCheckNotNullCall(checkNotNullCall)?.let { val completionResult = callCompleter.completeCall(it, data.expectedType) callCompleted = completionResult.callCompleted @@ -499,7 +490,6 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform // This can happen in erroneous code only resolvedAssignment } - // TODO: maybe replace with FirAbstractAssignment for performance? (result as? FirVariableAssignment)?.let { dataFlowAnalyzer.exitVariableAssignment(it) } return result.compose() } @@ -584,12 +574,11 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform ): CompositeTransformResult { constExpression.annotations.forEach { it.accept(this, data) } fun constructLiteralType(classId: ClassId, isNullable: Boolean = false): ConeKotlinType { - val symbol = symbolProvider.getClassLikeSymbolByFqName(classId) ?: return ConeClassErrorType("Missing stdlib class: ${classId}") + val symbol = symbolProvider.getClassLikeSymbolByFqName(classId) ?: return ConeClassErrorType("Missing stdlib class: $classId") return symbol.toLookupTag().constructClassType(emptyArray(), isNullable) } - val kind = constExpression.kind - val type = when (kind) { + val type = when (val kind = constExpression.kind) { FirConstKind.Null -> session.builtinTypes.nullableNothingType.type FirConstKind.Boolean -> session.builtinTypes.booleanType.type FirConstKind.Char -> constructLiteralType(StandardClassIds.Char) @@ -600,6 +589,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform FirConstKind.String -> constructLiteralType(StandardClassIds.String) FirConstKind.Float -> constructLiteralType(StandardClassIds.Float) FirConstKind.Double -> constructLiteralType(StandardClassIds.Double) + FirConstKind.IntegerLiteral, FirConstKind.UnsignedIntegerLiteral -> { val integerLiteralType = ConeIntegerLiteralTypeImpl(constExpression.value as Long, isUnsigned = kind == FirConstKind.UnsignedIntegerLiteral) @@ -608,6 +598,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform val approximatedType = integerLiteralType.getApproximatedType(expectedType) val newConstKind = approximatedType.toConstKind() if (newConstKind == null) { + @Suppress("UNCHECKED_CAST") constExpression.replaceKind(FirConstKind.Int as FirConstKind) dataFlowAnalyzer.exitConstExpresion(constExpression as FirConstExpression<*>) constExpression.resultType = buildErrorTypeRef { @@ -616,6 +607,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform } return constExpression.compose() } + @Suppress("UNCHECKED_CAST") constExpression.replaceKind(newConstKind as FirConstKind) approximatedType } else { @@ -656,6 +648,15 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform } + private inline fun withFirArrayOfCallTransformer(block: () -> T): T { + enableArrayOfCallTransformation = true + return try { + block() + } finally { + enableArrayOfCallTransformation = false + } + } + private fun ConeTypeProjection.toFirTypeProjection(): FirTypeProjection = when (this) { is ConeStarProjection -> buildStarProjection() else -> { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt index c853cf079c7..824fc14e9b0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt @@ -3,8 +3,6 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -@file:Suppress("DuplicatedCode") - package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve import org.jetbrains.kotlin.fir.FirElement @@ -30,7 +28,10 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.compose @OptIn(AdapterForResolveProcessor::class) -class FirImplicitTypeBodyResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) { +class FirImplicitTypeBodyResolveProcessor( + session: FirSession, + scopeSession: ScopeSession +) : FirTransformerBasedResolveProcessor(session, scopeSession) { override val transformer = FirImplicitTypeBodyResolveTransformerAdapter(session, scopeSession) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt index 3e7cba86ab4..28c4888aa22 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesNavigation.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve +import kotlinx.collections.immutable.PersistentList import kotlinx.collections.immutable.persistentListOf import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSymbolOwner @@ -18,7 +19,7 @@ class LocalClassesNavigationInfo( private val parentClassForFunction: Map, FirClass<*>>, val allMembers: List> ) { - val designationMap by lazy { + val designationMap: Map, List>> by lazy { parentClassForFunction.keys.keysToMap { pathForCallable(it) } @@ -45,10 +46,10 @@ fun FirClass<*>.collectLocalClassesNavigationInfo(): LocalClassesNavigationInfo } private class NavigationInfoVisitor : FirDefaultVisitorVoid() { - val resultingMap = mutableMapOf, FirClass<*>>() - val parentForClass = mutableMapOf, FirClass<*>?>() - val allMembers = mutableListOf>() - private var currentPath = persistentListOf>() + val resultingMap: MutableMap, FirClass<*>> = mutableMapOf() + val parentForClass: MutableMap, FirClass<*>?> = mutableMapOf() + val allMembers: MutableList> = mutableListOf() + private var currentPath: PersistentList> = persistentListOf() override fun visitElement(element: FirElement) {}