[FIR] Refactor boolean flags related to constructors: !no -> include

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

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 private operator fun <T> Pair<T, *>?.component1() = this?.first
 private operator fun <T> Pair<*, T>?.component2() = this?.second
@@ -32,8 +31,8 @@ internal fun FirScope.processConstructorsByName(
     name: Name,
     session: FirSession,
     bodyResolveComponents: BodyResolveComponents,
-    noSyntheticConstructors: Boolean,
-    noInnerConstructors: Boolean = false,
+    includeSyntheticConstructors: Boolean,
+    includeInnerConstructors: Boolean,
     processor: (FirCallableSymbol<*>) -> Unit
 ) {
     // TODO: Handle case with two or more accessible classifiers
@@ -48,18 +47,16 @@ internal fun FirScope.processConstructorsByName(
             processor,
             session,
             bodyResolveComponents.scopeSession,
-            noInnerConstructors
+            includeInnerConstructors
         )
 
-        if (noSyntheticConstructors) {
-            return
+        if (includeSyntheticConstructors) {
+            processSyntheticConstructors(
+                matchedClassSymbol,
+                processor,
+                bodyResolveComponents
+            )
         }
-
-        processSyntheticConstructors(
-            matchedClassSymbol,
-            processor,
-            bodyResolveComponents
-        )
     }
 }
 
@@ -67,13 +64,13 @@ internal fun FirScope.processFunctionsAndConstructorsByName(
     name: Name,
     session: FirSession,
     bodyResolveComponents: BodyResolveComponents,
-    noInnerConstructors: Boolean = false,
+    includeInnerConstructors: Boolean,
     processor: (FirCallableSymbol<*>) -> Unit
 ) {
     processConstructorsByName(
         name, session, bodyResolveComponents,
-        noSyntheticConstructors = false,
-        noInnerConstructors = noInnerConstructors,
+        includeSyntheticConstructors = true,
+        includeInnerConstructors = includeInnerConstructors,
         processor = processor
     )
 
@@ -93,16 +90,6 @@ private fun FirScope.getFirstClassifierOrNull(name: Name): Pair<FirClassifierSym
     return result
 }
 
-private fun finalExpansionName(symbol: FirTypeAliasSymbol, session: FirSession): Name? {
-    val expandedType = symbol.fir.expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>()
-    val typeAliasSymbol = expandedType.lookupTag.toSymbol(session)?.safeAs<FirTypeAliasSymbol>()
-
-    return if (typeAliasSymbol != null)
-        finalExpansionName(typeAliasSymbol, session)
-    else
-        expandedType.lookupTag.classId.shortClassName
-}
-
 private fun processSyntheticConstructors(
     matchedSymbol: FirClassLikeSymbol<*>?,
     processor: (FirFunctionSymbol<*>) -> Unit,
@@ -158,7 +145,7 @@ private fun processConstructors(
     processor: (FirFunctionSymbol<*>) -> Unit,
     session: FirSession,
     scopeSession: ScopeSession,
-    noInner: Boolean
+    includeInnerConstructors: Boolean
 ) {
     try {
         if (matchedSymbol != null) {
@@ -169,7 +156,7 @@ private fun processConstructors(
 
                     if (basicScope != null && type.typeArguments.isNotEmpty()) {
                         prepareSubstitutingScopeForTypeAliasConstructors(
-                            matchedSymbol, type, session, basicScope
+                            matchedSymbol, session, basicScope
                         ) ?: return
                     } else basicScope
                 }
@@ -181,7 +168,7 @@ private fun processConstructors(
 
             //TODO: why don't we use declared member scope at this point?
             scope?.processDeclaredConstructors {
-                if (!noInner || !it.fir.isInner) {
+                if (includeInnerConstructors || !it.fir.isInner) {
                     processor(it)
                 }
             }
@@ -246,11 +233,10 @@ private class TypeAliasConstructorsSubstitutor<F : FirFunction<F>>(
 
 private fun prepareSubstitutingScopeForTypeAliasConstructors(
     typeAliasSymbol: FirTypeAliasSymbol,
-    expandedType: ConeClassLikeType,
     session: FirSession,
     delegatingScope: FirScope
 ): FirScope? {
-    val copyFactory2: ConstructorCopyFactory<FirConstructor> = factory@ { newReturnType, newParameterTypes, newTypeParameters ->
+    val copyFactory2: ConstructorCopyFactory<FirConstructor> = factory@{ newReturnType, newParameterTypes, newTypeParameters ->
         buildConstructor {
             source = this@factory.source
             this.session = session

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/FirTowerResolverSession.kt

@@ -127,10 +127,10 @@ class FirTowerResolverSession internal constructor(
     private fun FirScope.toScopeTowerLevel(
         extensionReceiver: ReceiverValue? = null,
         extensionsOnly: Boolean = false,
-        noInnerConstructors: Boolean = false
+        includeInnerConstructors: Boolean = true
     ): ScopeTowerLevel = ScopeTowerLevel(
         session, components, this,
-        extensionReceiver, extensionsOnly, noInnerConstructors
+        extensionReceiver, extensionsOnly, includeInnerConstructors
     )
 
     private fun FirScope.toConstructorScopeTowerLevel(): ConstructorScopeTowerLevel =
@@ -151,7 +151,7 @@ class FirTowerResolverSession internal constructor(
         if (qualifierReceiver == null) return
         for ((depth, qualifierScope) in qualifierReceiver.callableScopes().withIndex()) {
             processLevel(
-                qualifierScope.toScopeTowerLevel(noInnerConstructors = true),
+                qualifierScope.toScopeTowerLevel(includeInnerConstructors = false),
                 info.noStubReceiver(), TowerGroup.Qualifier(depth),
                 useParentGroupForInvokes = true,
             )
@@ -169,7 +169,7 @@ class FirTowerResolverSession internal constructor(
         val scope = qualifierReceiver.classifierScope() ?: return
         val group = if (prioritized) TowerGroup.ClassifierPrioritized else TowerGroup.Classifier
         processLevel(
-            scope.toScopeTowerLevel(noInnerConstructors = true), info.noStubReceiver(),
+            scope.toScopeTowerLevel(includeInnerConstructors = false), info.noStubReceiver(),
             group,
             useParentGroupForInvokes = true,
         )

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt

@@ -82,7 +82,7 @@ class MemberScopeTowerLevel(
 ) : SessionBasedTowerLevel(session) {
     private fun <T : AbstractFirBasedSymbol<*>> processMembers(
         output: TowerScopeLevel.TowerScopeLevelProcessor<T>,
-        forInnerConstructors: Boolean = false,
+        forInnerConstructorDelegationCalls: Boolean = false,
         processScopeMembers: FirScope.(processor: (T) -> Unit) -> Unit
     ): ProcessorAction {
         var empty = true
@@ -93,10 +93,8 @@ class MemberScopeTowerLevel(
                 (implicitExtensionInvokeMode || candidate.hasConsistentExtensionReceiver(extensionReceiver))
             ) {
                 val fir = candidate.fir
-                if (forInnerConstructors) {
-                    if (candidate !is FirConstructorSymbol || !candidate.fir.isInner) {
-                        return@processScopeMembers
-                    }
+                if (forInnerConstructorDelegationCalls && candidate !is FirConstructorSymbol) {
+                    return@processScopeMembers
                 } else if ((fir as? FirCallableMemberDeclaration<*>)?.isStatic == true || (fir as? FirConstructor)?.isInner == false) {
                     return@processScopeMembers
                 }
@@ -119,7 +117,7 @@ class MemberScopeTowerLevel(
             }
         }
 
-        if (!forInnerConstructors) {
+        if (!forInnerConstructorDelegationCalls) {
             val withSynthetic = FirSyntheticPropertiesScope(session, scope)
             withSynthetic.processScopeMembers { symbol ->
                 empty = false
@@ -149,7 +147,7 @@ class MemberScopeTowerLevel(
             TowerScopeLevel.Token.Functions -> processMembers(processor) { consumer ->
                 this.processFunctionsAndConstructorsByName(
                     name, session, bodyResolveComponents,
-                    noInnerConstructors = false,
+                    includeInnerConstructors = true,
                     processor = {
                         // WARNING, DO NOT CAST FUNCTIONAL TYPE ITSELF
                         @Suppress("UNCHECKED_CAST")
@@ -164,11 +162,11 @@ class MemberScopeTowerLevel(
                     consumer(it as T)
                 }
             }
-            TowerScopeLevel.Token.Constructors -> processMembers(processor, forInnerConstructors = true) { consumer ->
+            TowerScopeLevel.Token.Constructors -> processMembers(processor, forInnerConstructorDelegationCalls = true) { consumer ->
                 this.processConstructorsByName(
                     name, session, bodyResolveComponents,
-                    noSyntheticConstructors = true,
-                    noInnerConstructors = false,
+                    includeSyntheticConstructors = false,
+                    includeInnerConstructors = true,
                     processor = {
                         @Suppress("UNCHECKED_CAST")
                         consumer(it as T)
@@ -198,7 +196,7 @@ class ScopeTowerLevel(
     val scope: FirScope,
     val extensionReceiver: ReceiverValue?,
     private val extensionsOnly: Boolean,
-    private val noInnerConstructors: Boolean
+    private val includeInnerConstructors: Boolean
 ) : SessionBasedTowerLevel(session) {
     private fun FirCallableSymbol<*>.hasConsistentReceivers(extensionReceiver: Receiver?): Boolean =
         when {
@@ -261,7 +259,7 @@ class ScopeTowerLevel(
                 name,
                 session,
                 bodyResolveComponents,
-                noInnerConstructors = noInnerConstructors
+                includeInnerConstructors = includeInnerConstructors
             ) { candidate ->
                 empty = false
                 if (candidate.hasConsistentReceivers(extensionReceiver)) {
@@ -302,6 +300,7 @@ class ConstructorScopeTowerLevel(
                 // NB: here we cannot resolve inner constructors, because they should have dispatch receiver
                 if (!candidate.fir.isInner) {
                     empty = false
+                    @Suppress("UNCHECKED_CAST")
                     processor.consumeCandidate(
                         candidate as T,
                         dispatchReceiverValue = null,