diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ScopeTowerProcessors.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ScopeTowerProcessors.kt
index 32a0d531226..ab90436e1be 100644
--- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ScopeTowerProcessors.kt
+++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ScopeTowerProcessors.kt
@@ -31,20 +31,23 @@ class KnownResultProcessor<out C>(
             = if (data == TowerData.Empty) listOfNotNull(result.takeIf { it.isNotEmpty() }) else emptyList()
 }
 
+// use this if processors priority is important
 class CompositeScopeTowerProcessor<out C>(
         vararg val processors: ScopeTowerProcessor<C>
 ) : ScopeTowerProcessor<C> {
     override fun process(data: TowerData): List<Collection<C>> = processors.flatMap { it.process(data) }
 }
 
+// use this if all processors has same priority
+class CompositeSimpleScopeTowerProcessor<C : Candidate>(
+        private vararg val processors: SimpleScopeTowerProcessor<C>
+): SimpleScopeTowerProcessor<C> {
+    override fun simpleProcess(data: TowerData): Collection<C> = processors.flatMap { it.simpleProcess(data) }
+}
+
 internal abstract class AbstractSimpleScopeTowerProcessor<C: Candidate>(
         val candidateFactory: CandidateFactory<C>
-) : ScopeTowerProcessor<C> {
-
-    protected abstract fun simpleProcess(data: TowerData): Collection<C>
-
-    override fun process(data: TowerData): List<Collection<C>> = listOfNotNull(simpleProcess(data).takeIf { it.isNotEmpty() })
-}
+) : SimpleScopeTowerProcessor<C>
 
 private typealias CandidatesCollector =
     ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver>
@@ -161,6 +164,23 @@ private fun <D : CallableDescriptor, C : Candidate> processCommonAndSyntheticMem
            }
 }
 
+private fun <C : Candidate> createSimpleProcessorWithoutClassValueReceiver(
+        scopeTower: ImplicitScopeTower,
+        context: CandidateFactory<C>,
+        explicitReceiver: DetailedReceiver?,
+        collectCandidates: CandidatesCollector
+): SimpleScopeTowerProcessor<C> =
+        when (explicitReceiver) {
+            is ReceiverValueWithSmartCastInfo -> ExplicitReceiverScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates)
+            is QualifierReceiver -> QualifierScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates)
+            else -> {
+                assert(explicitReceiver == null) {
+                    "Illegal explicit receiver: $explicitReceiver(${explicitReceiver!!::class.java.simpleName})"
+                }
+                NoExplicitReceiverScopeTowerProcessor(context, collectCandidates)
+            }
+        }
+
 private fun <C : Candidate> createSimpleProcessor(
         scopeTower: ImplicitScopeTower,
         context: CandidateFactory<C>,
@@ -168,28 +188,23 @@ private fun <C : Candidate> createSimpleProcessor(
         classValueReceiver: Boolean,
         collectCandidates: CandidatesCollector
 ) : ScopeTowerProcessor<C> {
-    return when (explicitReceiver) {
-        is ReceiverValueWithSmartCastInfo -> {
-            ExplicitReceiverScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates)
-        }
-        is QualifierReceiver -> {
-            val qualifierProcessor = QualifierScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates)
-            if (!classValueReceiver) return qualifierProcessor
+    val withoutClassValueProcessor = createSimpleProcessorWithoutClassValueReceiver(scopeTower, context, explicitReceiver, collectCandidates)
 
-            // todo enum entry, object.
-            val classValue = explicitReceiver.classValueReceiverWithSmartCastInfo ?: return qualifierProcessor
-            CompositeScopeTowerProcessor(
-                    qualifierProcessor,
-                    ExplicitReceiverScopeTowerProcessor(scopeTower, context, classValue, collectCandidates)
-            )
-        }
-        else -> {
-            assert(explicitReceiver == null) {
-                "Illegal explicit receiver: $explicitReceiver(${explicitReceiver!!::class.java.simpleName})"
-            }
-            NoExplicitReceiverScopeTowerProcessor(context, collectCandidates)
-        }
+    if (classValueReceiver && explicitReceiver is QualifierReceiver) {
+        val classValue = explicitReceiver.classValueReceiverWithSmartCastInfo ?: return withoutClassValueProcessor
+        return CompositeScopeTowerProcessor(
+                withoutClassValueProcessor,
+                ExplicitReceiverScopeTowerProcessor(scopeTower, context, classValue, collectCandidates)
+        )
     }
+    return withoutClassValueProcessor
+}
+
+fun <C : Candidate> createCallableReferenceProcessor(scopeTower: ImplicitScopeTower, name: Name, context: CandidateFactory<C>,
+                                                     explicitReceiver: DetailedReceiver?): SimpleScopeTowerProcessor<C> {
+    val variable = createSimpleProcessorWithoutClassValueReceiver(scopeTower, context, explicitReceiver) { getVariables(name, it) }
+    val function = createSimpleProcessorWithoutClassValueReceiver(scopeTower, context, explicitReceiver) { getFunctions(name, it) }
+    return CompositeSimpleScopeTowerProcessor(variable, function)
 }
 
 fun <C : Candidate> createVariableProcessor(scopeTower: ImplicitScopeTower, name: Name,
diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt
index 01da1e18767..e97da56bccb 100644
--- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt
+++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt
@@ -64,6 +64,12 @@ interface ScopeTowerProcessor<out C> {
     fun process(data: TowerData): List<Collection<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() })
+}
+
 class TowerResolver {
     fun <C: Candidate> runResolve(
             scopeTower: ImplicitScopeTower,