[FIR] Cleanup FIR modules. Part 5 (body.resolve package)

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)
     }
 }
-

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<FirStatement> {
+    override fun transformThrowExpression(
+        throwExpression: FirThrowExpression,
+        data: ResolutionMode
+    ): CompositeTransformResult<FirStatement> {
         return transformer.transformExpression(throwExpression, data).also {
             dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression)
         }

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()

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 <T> withFirArrayOfCallTransformer(block: () -> T): T {
-        enableArrayOfCallTransformation = true
-        return try {
-            block()
-        } finally {
-            enableArrayOfCallTransformation = false
-        }
-    }
-
     override fun transformExpression(expression: FirExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
         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<FirStatement> {
         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 (val kind = constExpression.kind) {
-        val type = when (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<T>)
                         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<T>)
                     approximatedType
                 } else {
@@ -656,6 +648,15 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform
 
     }
 
+    private inline fun <T> withFirArrayOfCallTransformer(block: () -> T): T {
+        enableArrayOfCallTransformation = true
+        return try {
+            block()
+        } finally {
+            enableArrayOfCallTransformation = false
+        }
+    }
+
     private fun ConeTypeProjection.toFirTypeProjection(): FirTypeProjection = when (this) {
         is ConeStarProjection -> buildStarProjection()
         else -> {

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)
 }
 

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<FirCallableMemberDeclaration<*>, FirClass<*>>,
     val allMembers: List<FirSymbolOwner<*>>
 ) {
-    val designationMap by lazy {
+    val designationMap: Map<FirCallableMemberDeclaration<*>, List<FirClass<*>>> by lazy {
         parentClassForFunction.keys.keysToMap {
             pathForCallable(it)
         }
@@ -45,10 +46,10 @@ fun FirClass<*>.collectLocalClassesNavigationInfo(): LocalClassesNavigationInfo
     }
 
 private class NavigationInfoVisitor : FirDefaultVisitorVoid() {
-    val resultingMap = mutableMapOf<FirCallableMemberDeclaration<*>, FirClass<*>>()
+    val resultingMap: MutableMap<FirCallableMemberDeclaration<*>, FirClass<*>> = mutableMapOf()
-    val parentForClass = mutableMapOf<FirClass<*>, FirClass<*>?>()
+    val parentForClass: MutableMap<FirClass<*>, FirClass<*>?> = mutableMapOf()
-    val allMembers = mutableListOf<FirSymbolOwner<*>>()
+    val allMembers: MutableList<FirSymbolOwner<*>> = mutableListOf()
-    private var currentPath = persistentListOf<FirClass<*>>()
+    private var currentPath: PersistentList<FirClass<*>> = persistentListOf()
 
     override fun visitElement(element: FirElement) {}