Factor duplicated code.

Move SimpleScopeTowerProcessor from TowerResolver into ScopeTowerProcessors.

Lift code duplicated in functions:

  * ExplicitReceiverScopeTowerProcessor.simpleProcess()
  * QualifierScopeTowerProcessor.simpleProcess()
  * NoExplicitReceiverScopeTowerProcessor.simpleProcess()

into AbstractSimpleScopeTowerProcessor. Turn it into a function and call it
in the various context. Incidentally, now useless functions resolveAsMember()
and resolveAsExtension() are  removed.

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ScopeTowerProcessors.kt

@@ -54,9 +54,31 @@ class SamePriorityCompositeScopeTowerProcessor<out C>(
 
 }
 
+interface SimpleScopeTowerProcessor<out C> : ScopeTowerProcessor<C> {
+    fun simpleProcess(data: TowerData): Collection<C>
+
+    override fun process(data: TowerData): List<Collection<C>> = listOfNotNull(simpleProcess(data).takeIf { it.isNotEmpty() })
+}
+
 internal abstract class AbstractSimpleScopeTowerProcessor<C : Candidate>(
     val candidateFactory: CandidateFactory<C>
-) : SimpleScopeTowerProcessor<C>
+) : SimpleScopeTowerProcessor<C> {
+    fun resolve(collector: Collection<CandidateWithBoundDispatchReceiver>, f:(Boolean)->Boolean, kind: ExplicitReceiverKind, receiver: ReceiverValueWithSmartCastInfo?) : Collection<C> {
+        val result = mutableListOf<C>()
+        for (candidate in collector) {
+            if (f(candidate.requiresExtensionReceiver)) {
+                result.add(
+                    candidateFactory.createCandidate(
+                        candidate,
+                        kind,
+                        extensionReceiver = receiver
+                    )
+                )
+            }
+        }
+        return result
+    }
+}
 
 private typealias CandidatesCollector =
         ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver>
@@ -69,44 +91,20 @@ internal class ExplicitReceiverScopeTowerProcessor<C : Candidate>(
 ) : AbstractSimpleScopeTowerProcessor<C>(context) {
     override fun simpleProcess(data: TowerData): Collection<C> {
         return when (data) {
-            TowerData.Empty -> resolveAsMember()
+            TowerData.Empty -> resolve(
-            is TowerData.TowerLevel -> resolveAsExtension(data.level)
+                MemberScopeTowerLevel(scopeTower, explicitReceiver).collectCandidates(null),
+                { !it },
+                ExplicitReceiverKind.DISPATCH_RECEIVER,
+                null)
+            is TowerData.TowerLevel -> resolve(
+                data.level.collectCandidates(explicitReceiver),
+                { it },
+                ExplicitReceiverKind.EXTENSION_RECEIVER,
+                explicitReceiver)
             else -> emptyList()
         }
     }
 
-    private fun resolveAsMember(): Collection<C> {
-        val members = mutableListOf<C>()
-        for (memberCandidate in MemberScopeTowerLevel(scopeTower, explicitReceiver).collectCandidates(null)) {
-            if (!memberCandidate.requiresExtensionReceiver) {
-                members.add(
-                    candidateFactory.createCandidate(
-                        memberCandidate,
-                        ExplicitReceiverKind.DISPATCH_RECEIVER,
-                        extensionReceiver = null
-                    )
-                )
-            }
-        }
-        return members
-    }
-
-    private fun resolveAsExtension(level: ScopeTowerLevel): Collection<C> {
-        val extensions = mutableListOf<C>()
-        for (extensionCandidate in level.collectCandidates(explicitReceiver)) {
-            if (extensionCandidate.requiresExtensionReceiver) {
-                extensions.add(
-                    candidateFactory.createCandidate(
-                        extensionCandidate,
-                        ExplicitReceiverKind.EXTENSION_RECEIVER,
-                        extensionReceiver = explicitReceiver
-                    )
-                )
-            }
-        }
-        return extensions
-    }
-
     override fun recordLookups(skippedData: Collection<TowerData>, name: Name) {
         for (data in skippedData) {
             if (data is TowerData.TowerLevel) {
@@ -125,19 +123,12 @@ private class QualifierScopeTowerProcessor<C : Candidate>(
     override fun simpleProcess(data: TowerData): Collection<C> {
         if (data != TowerData.Empty) return emptyList()
 
-        val staticMembers = mutableListOf<C>()
+        return resolve(
-        for (towerCandidate in QualifierScopeTowerLevel(scopeTower, qualifier).collectCandidates(null)) {
+            QualifierScopeTowerLevel(scopeTower, qualifier).collectCandidates(null),
-            if (!towerCandidate.requiresExtensionReceiver) {
+            { !it },
-                staticMembers.add(
+            ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
-                    candidateFactory.createCandidate(
+            null
-                        towerCandidate,
+        )
-                        ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
-                        extensionReceiver = null
-                    )
-                )
-            }
-        }
-        return staticMembers
     }
 
     // QualifierScopeTowerProcessor works only with TowerData.Empty that should not be ignored
@@ -149,36 +140,16 @@ private class NoExplicitReceiverScopeTowerProcessor<C : Candidate>(
     val collectCandidates: CandidatesCollector
 ) : AbstractSimpleScopeTowerProcessor<C>(context) {
     override fun simpleProcess(data: TowerData): Collection<C> = when (data) {
-        is TowerData.TowerLevel -> {
+        is TowerData.TowerLevel -> resolve(
-            val result = mutableListOf<C>()
+            data.level.collectCandidates(null),
-            for (towerCandidate in data.level.collectCandidates(null)) {
+            { !it },
-                if (!towerCandidate.requiresExtensionReceiver) {
+            ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
-                    result.add(
+            null)
-                        candidateFactory.createCandidate(
+        is TowerData.BothTowerLevelAndImplicitReceiver -> resolve(
-                            towerCandidate,
+            data.level.collectCandidates(data.implicitReceiver),
-                            ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
+            { it },
-                            extensionReceiver = null
+            ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
-                        )
+            data.implicitReceiver)
-                    )
-                }
-            }
-            result
-        }
-        is TowerData.BothTowerLevelAndImplicitReceiver -> {
-            val result = mutableListOf<C>()
-            for (towerCandidate in data.level.collectCandidates(data.implicitReceiver)) {
-                if (towerCandidate.requiresExtensionReceiver) {
-                    result.add(
-                        candidateFactory.createCandidate(
-                            towerCandidate,
-                            ExplicitReceiverKind.NO_EXPLICIT_RECEIVER,
-                            extensionReceiver = data.implicitReceiver
-                        )
-                    )
-                }
-            }
-            result
-        }
         else -> emptyList()
     }
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt

@@ -74,12 +74,6 @@ interface ScopeTowerProcessor<out C> {
     fun recordLookups(skippedData: Collection<TowerData>, name: Name)
 }
 
-interface SimpleScopeTowerProcessor<out C> : ScopeTowerProcessor<C> {
-    fun simpleProcess(data: TowerData): Collection<C>
-
-    override fun process(data: TowerData): List<Collection<C>> = listOfNotNull(simpleProcess(data).takeIf { it.isNotEmpty() })
-}
-
 class TowerResolver {
     fun <C : Candidate> runResolve(
         scopeTower: ImplicitScopeTower,