[FIR] Extract ConstructorScopeTowerLevel

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

@@ -133,6 +133,9 @@ class FirTowerResolverSession internal constructor(
         extensionReceiver, extensionsOnly, noInnerConstructors
     )
 
+    private fun FirScope.toConstructorScopeTowerLevel(): ConstructorScopeTowerLevel =
+        ConstructorScopeTowerLevel(session, this)
+
     private fun ReceiverValue.toMemberScopeTowerLevel(
         extensionReceiver: ReceiverValue? = null,
         implicitExtensionInvokeMode: Boolean = false
@@ -217,7 +220,7 @@ class FirTowerResolverSession internal constructor(
         } else {
             // Search for non-inner constructors only
             processLevel(
-                scope.toScopeTowerLevel(),
+                scope.toConstructorScopeTowerLevel(),
                 info, TowerGroup.Member
             )
         }

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

@@ -196,9 +196,9 @@ class ScopeTowerLevel(
     session: FirSession,
     private val bodyResolveComponents: BodyResolveComponents,
     val scope: FirScope,
-    val extensionReceiver: ReceiverValue? = null,
-    private val extensionsOnly: Boolean = false,
-    private val noInnerConstructors: Boolean = false
+    val extensionReceiver: ReceiverValue?,
+    private val extensionsOnly: Boolean,
+    private val noInnerConstructors: Boolean
 ) : SessionBasedTowerLevel(session) {
     private fun FirCallableSymbol<*>.hasConsistentReceivers(extensionReceiver: Receiver?): Boolean =
         when {
@@ -279,15 +279,39 @@ class ScopeTowerLevel(
                     implicitExtensionReceiverValue = null
                 )
             }
+            TowerScopeLevel.Token.Constructors -> {
+                throw AssertionError("Should not be here")
+            }
+        }
+        return if (empty) ProcessorAction.NONE else ProcessorAction.NEXT
+    }
+}
+
+class ConstructorScopeTowerLevel(
+    session: FirSession,
+    val scope: FirScope
+) : SessionBasedTowerLevel(session) {
+    override fun <T : AbstractFirBasedSymbol<*>> processElementsByName(
+        token: TowerScopeLevel.Token<T>,
+        name: Name,
+        processor: TowerScopeLevel.TowerScopeLevelProcessor<T>
+    ): ProcessorAction {
+        var empty = true
+        when (token) {
             TowerScopeLevel.Token.Constructors -> scope.processDeclaredConstructors { candidate ->
                 // NB: here we cannot resolve inner constructors, because they should have dispatch receiver
                 if (!candidate.fir.isInner) {
+                    empty = false
                     processor.consumeCandidate(
-                        candidate as T, dispatchReceiverValue(scope, candidate),
+                        candidate as T,
+                        dispatchReceiverValue = null,
                         implicitExtensionReceiverValue = null
                     )
                 }
             }
+            else -> {
+                throw AssertionError("Should not be here: token = $token")
+            }
         }
         return if (empty) ProcessorAction.NONE else ProcessorAction.NEXT
     }