[FIR] Remove useSiteSession parameter from ensureResolved

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityDeclarationChecker.kt

@@ -200,7 +200,7 @@ object FirExposedVisibilityDeclarationChecker : FirBasicDeclarationChecker() {
     ): FirMemberDeclaration? {
         val type = this as? ConeClassLikeType ?: return null
         val fir = type.fullyExpandedType(context.session).lookupTag.toSymbol(context.session)?.let { firSymbol ->
-            firSymbol.ensureResolved(FirResolvePhase.DECLARATIONS, context.session)
+            firSymbol.ensureResolved(FirResolvePhase.DECLARATIONS)
             firSymbol.fir
         } ?: return null
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/declarations/InlineClassesUtils.kt

@@ -30,7 +30,7 @@ internal fun ConeKotlinType.unsubstitutedUnderlyingTypeForInlineClass(session: F
         ?.lookupTag
         ?.toSymbol(session) as? FirRegularClassSymbol
         ?: return null
-    symbol.ensureResolved(FirResolvePhase.STATUS, session)
+    symbol.ensureResolved(FirResolvePhase.STATUS)
     return symbol.fir.getInlineClassUnderlyingParameter()?.returnTypeRef?.coneType
 }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -140,7 +140,7 @@ fun BodyResolveComponents.typeForQualifier(resolvedQualifier: FirResolvedQualifi
     val classSymbol = resolvedQualifier.symbol
     val resultType = resolvedQualifier.resultType
     if (classSymbol != null) {
-        classSymbol.ensureResolved(FirResolvePhase.DECLARATIONS, session)
+        classSymbol.ensureResolved(FirResolvePhase.DECLARATIONS)
         val declaration = classSymbol.fir
         if (declaration !is FirTypeAlias || resolvedQualifier.typeArguments.isEmpty()) {
             typeForQualifierByDeclaration(declaration, resultType, session)?.let { return it }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt

@@ -63,7 +63,7 @@ private fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: Scope
             val fullyExpandedType = fullyExpandedType(useSiteSession)
             val fir = fullyExpandedType.lookupTag.toSymbol(useSiteSession)?.fir as? FirClass ?: return null
 
-            fir.symbol.ensureResolved(requiredPhase, useSiteSession)
+            fir.symbol.ensureResolved(requiredPhase)
 
             val substitution = createSubstitution(fir.typeParameters, fullyExpandedType, useSiteSession)
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt

@@ -33,13 +33,13 @@ abstract class SupertypeSupplier {
         override fun forClass(firClass: FirClass, useSiteSession: FirSession): List<ConeClassLikeType> {
             if (!firClass.isLocal) {
                 // for local classes the phase may not be updated till that moment
-                firClass.ensureResolved(FirResolvePhase.SUPER_TYPES, useSiteSession)
+                firClass.ensureResolved(FirResolvePhase.SUPER_TYPES)
             }
             return firClass.superConeTypes
         }
 
         override fun expansionForTypeAlias(typeAlias: FirTypeAlias, useSiteSession: FirSession): ConeClassLikeType? {
-            typeAlias.ensureResolved(FirResolvePhase.SUPER_TYPES, useSiteSession)
+            typeAlias.ensureResolved(FirResolvePhase.SUPER_TYPES)
             return typeAlias.expandedConeType
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/TypeExpansionUtils.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.utils.component2
 fun ConeClassLikeType.fullyExpandedType(
     useSiteSession: FirSession,
     expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = { alias ->
-        alias.ensureResolved(FirResolvePhase.SUPER_TYPES, useSiteSession)
+        alias.ensureResolved(FirResolvePhase.SUPER_TYPES)
         alias.expandedConeType
     },
 ): ConeClassLikeType {
@@ -61,7 +61,7 @@ private fun ConeClassLikeType.fullyExpandedTypeNoCache(
 fun ConeClassLikeType.directExpansionType(
     useSiteSession: FirSession,
     expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = { alias ->
-        alias.ensureResolved(FirResolvePhase.SUPER_TYPES, useSiteSession)
+        alias.ensureResolved(FirResolvePhase.SUPER_TYPES)
         alias.expandedConeType
     },
 ): ConeClassLikeType? {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt

@@ -173,7 +173,7 @@ private fun processConstructors(
         if (matchedSymbol != null) {
             val scope = when (matchedSymbol) {
                 is FirTypeAliasSymbol -> {
-                    matchedSymbol.ensureResolved(FirResolvePhase.TYPES, session)
+                    matchedSymbol.ensureResolved(FirResolvePhase.TYPES)
                     val type = matchedSymbol.fir.expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>().fullyExpandedType(session)
                     val basicScope = type.scope(session, bodyResolveComponents.scopeSession, FakeOverrideTypeCalculator.DoNothing)
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt

@@ -70,7 +70,7 @@ class FirSealedClassInheritorsProcessor(
             return when (classLikeSymbol) {
                 is FirRegularClassSymbol -> classLikeSymbol.fir
                 is FirTypeAliasSymbol -> {
-                    classLikeSymbol.ensureResolved(FirResolvePhase.SUPER_TYPES, symbolProvider.session)
+                    classLikeSymbol.ensureResolved(FirResolvePhase.SUPER_TYPES)
                     extractClassFromTypeRef(symbolProvider, classLikeSymbol.fir.expandedTypeRef)
                 }
                 else -> null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt

@@ -159,7 +159,7 @@ open class FirDesignatedStatusResolveTransformer(
         data: FirResolvedDeclarationStatus?
     ): FirStatement {
         if (shouldSkipClass(regularClass)) return regularClass
-        regularClass.symbol.ensureResolved(FirResolvePhase.TYPES, session)
+        regularClass.symbol.ensureResolved(FirResolvePhase.TYPES)
         val classLocated = this.classLocated
         /*
          * In designated status resolve we should resolve status only of target class and it's members
@@ -393,7 +393,7 @@ abstract class AbstractFirStatusResolveTransformer(
 
     private fun forceResolveStatusOfCorrespondingClass(typeRef: FirTypeRef) {
         val superClass = typeRef.coneType.toSymbol(session)?.fir
-        superClass?.ensureResolved(FirResolvePhase.SUPER_TYPES, session)
+        superClass?.ensureResolved(FirResolvePhase.SUPER_TYPES)
         when (superClass) {
             is FirRegularClass -> forceResolveStatusesOfClass(superClass)
             is FirTypeAlias -> forceResolveStatusOfCorrespondingClass(superClass.expandedTypeRef)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/PhaseUtils.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
 
 fun FirBasedSymbol<*>.ensureResolvedForCalls(
-    useSiteSession: FirSession,
+    @Suppress("UNUSED_PARAMETER") useSiteSession: FirSession,
 ) {
     if (fir.resolvePhase >= FirResolvePhase.DECLARATIONS) return
 
@@ -35,7 +35,7 @@ fun FirBasedSymbol<*>.ensureResolvedForCalls(
 
     val requiredPhase = FirResolvePhase.DECLARATIONS
 
-    ensureResolved(requiredPhase, useSiteSession)
+    ensureResolved(requiredPhase)
 }
 
 fun ConeKotlinType.ensureResolvedTypeDeclaration(
@@ -44,8 +44,8 @@ fun ConeKotlinType.ensureResolvedTypeDeclaration(
 ) {
     if (this !is ConeClassLikeType) return
 
-    lookupTag.toSymbol(useSiteSession)?.ensureResolved(requiredPhase, useSiteSession)
+    lookupTag.toSymbol(useSiteSession)?.ensureResolved(requiredPhase)
-    fullyExpandedType(useSiteSession).lookupTag.toSymbol(useSiteSession)?.ensureResolved(requiredPhase, useSiteSession)
+    fullyExpandedType(useSiteSession).lookupTag.toSymbol(useSiteSession)?.ensureResolved(requiredPhase)
 }
 
 fun FirTypeRef.ensureResolvedTypeDeclaration(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt

@@ -49,7 +49,7 @@ class FirDelegatedMemberScope(
     }
 
     private fun buildScope(delegateField: FirField): FirTypeScope? {
-        delegateField.ensureResolved(FirResolvePhase.TYPES, session)
+        delegateField.ensureResolved(FirResolvePhase.TYPES)
         return delegateField.returnTypeRef.coneType.scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing)
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt

@@ -132,8 +132,8 @@ class FirStandardOverrideChecker(private val session: FirSession) : FirAbstractO
 
         val substitutor = buildTypeParametersSubstitutorIfCompatible(overrideCandidate, baseDeclaration) ?: return false
 
-        overrideCandidate.ensureResolved(FirResolvePhase.TYPES, useSiteSession = session)
+        overrideCandidate.ensureResolved(FirResolvePhase.TYPES)
-        baseDeclaration.ensureResolved(FirResolvePhase.TYPES, useSiteSession = session)
+        baseDeclaration.ensureResolved(FirResolvePhase.TYPES)
 
         if (!isEqualReceiverTypes(overrideCandidate.receiverTypeRef, baseDeclaration.receiverTypeRef, substitutor)) return false
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt

@@ -261,7 +261,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
             is ConeTypeVariableTypeConstructor -> emptyList()
             is ConeTypeParameterLookupTag -> symbol.fir.bounds.map { it.coneType }
             is ConeClassLikeLookupTag -> {
-                when (val symbol = toClassLikeSymbol().also { it?.ensureResolved(FirResolvePhase.TYPES, session) }) {
+                when (val symbol = toClassLikeSymbol().also { it?.ensureResolved(FirResolvePhase.TYPES) }) {
                     is FirClassSymbol<*> -> symbol.fir.superConeTypes
                     is FirTypeAliasSymbol -> listOfNotNull(symbol.fir.expandedConeType)
                     else -> listOf(session.builtinTypes.anyType.type)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirPhaseManager.kt

@@ -19,20 +19,12 @@ abstract class FirPhaseManager : FirSessionComponent {
 
 val FirSession.phaseManager: FirPhaseManager by FirSession.sessionComponentAccessor()
 
-fun FirBasedSymbol<*>.ensureResolved(
+fun FirBasedSymbol<*>.ensureResolved(requiredPhase: FirResolvePhase) {
-    requiredPhase: FirResolvePhase,
-    // TODO: Currently, the parameter is unused but it's needed to guarantee that all call-sites are able to supply use-site session
-    // TODO: Decide which one session should be used and probably get rid of the parameter if use-site session is not needed
-    @Suppress("UNUSED_PARAMETER") useSiteSession: FirSession,
-) {
     val session = fir.moduleData.session
     val phaseManager = session.phaseManager
     phaseManager.ensureResolved(this, requiredPhase)
 }
 
-fun FirDeclaration.ensureResolved(
+fun FirDeclaration.ensureResolved(requiredPhase: FirResolvePhase) {
-    requiredPhase: FirResolvePhase,
+    symbol.ensureResolved(requiredPhase)
-    useSiteSession: FirSession,
-) {
-    symbol.ensureResolved(requiredPhase, useSiteSession)
 }