Rename ScopeTower to ImplicitScopeTower.

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt

@@ -67,7 +67,7 @@ class NewResolutionOldInference(
                 outer: NewResolutionOldInference,
                 name: Name,
                 tracing: TracingStrategy,
-                scopeTower: ScopeTower,
+                scopeTower: ImplicitScopeTower,
                 explicitReceiver: DetailedReceiver?,
                 context: BasicCallResolutionContext
         ): ScopeTowerProcessor<MyCandidate<D>>
@@ -75,7 +75,7 @@ class NewResolutionOldInference(
         object Function : ResolutionKind<FunctionDescriptor>() {
             override fun createTowerProcessor(
                     outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
-                    scopeTower: ScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
+                    scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
             ): ScopeTowerProcessor<MyCandidate<FunctionDescriptor>> {
                 val functionContext = outer.SimpleContext<FunctionDescriptor>(scopeTower, name, context, tracing)
                 return createFunctionProcessor(functionContext, outer.InvokeContext(functionContext), explicitReceiver)
@@ -85,7 +85,7 @@ class NewResolutionOldInference(
         object Variable : ResolutionKind<VariableDescriptor>() {
             override fun createTowerProcessor(
                     outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
-                    scopeTower: ScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
+                    scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
             ): ScopeTowerProcessor<MyCandidate<VariableDescriptor>> {
                 val simpleContext = outer.SimpleContext<VariableDescriptor>(scopeTower, name, context, tracing)
                 return createVariableAndObjectProcessor(simpleContext, explicitReceiver)
@@ -95,7 +95,7 @@ class NewResolutionOldInference(
         object CallableReference : ResolutionKind<CallableDescriptor>() {
             override fun createTowerProcessor(
                     outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
-                    scopeTower: ScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
+                    scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
             ): ScopeTowerProcessor<MyCandidate<CallableDescriptor>> {
                 val simpleContextF = outer.SimpleContext<FunctionDescriptor>(scopeTower, name, context, tracing)
                 val simpleContextV = outer.SimpleContext<VariableDescriptor>(scopeTower, name, context, tracing)
@@ -109,7 +109,7 @@ class NewResolutionOldInference(
         object Invoke : ResolutionKind<FunctionDescriptor>() {
             override fun createTowerProcessor(
                     outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
-                    scopeTower: ScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
+                    scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
             ): ScopeTowerProcessor<MyCandidate<FunctionDescriptor>> {
                 val functionContext = outer.SimpleContext<FunctionDescriptor>(scopeTower, name, context, tracing)
                 // todo
@@ -126,7 +126,7 @@ class NewResolutionOldInference(
         class GivenCandidates<D : CallableDescriptor> : ResolutionKind<D>() {
             override fun createTowerProcessor(
                     outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
-                    scopeTower: ScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
+                    scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
             ): ScopeTowerProcessor<MyCandidate<D>> {
                 throw IllegalStateException("Should be not called")
             }
@@ -148,7 +148,7 @@ class NewResolutionOldInference(
         }
 
         val dynamicScope = dynamicCallableDescriptors.createDynamicDescriptorScope(context.call, context.scope.ownerDescriptor)
-        val scopeTower = ScopeTowerImpl(context, dynamicScope, syntheticScopes, context.call.createLookupLocation())
+        val scopeTower = ImplicitScopeTowerImpl(context, dynamicScope, syntheticScopes, context.call.createLookupLocation())
 
         val processor = kind.createTowerProcessor(this, name, tracing, scopeTower, detailedReceiver, context)
 
@@ -242,12 +242,12 @@ class NewResolutionOldInference(
         return resolutionResultsHandler.computeResultAndReportErrors(basicCallContext, tracing, resolvedCalls)
     }
 
-    private class ScopeTowerImpl(
+    private class ImplicitScopeTowerImpl(
             val resolutionContext: ResolutionContext<*>,
             override val dynamicScope: MemberScope,
             override val syntheticScopes: SyntheticScopes,
             override val location: LookupLocation
-    ): ScopeTower {
+    ): ImplicitScopeTower {
         private val cache = HashMap<ReceiverValue, ReceiverValueWithSmartCastInfo>()
 
         override fun getImplicitReceiver(scope: LexicalScope): ReceiverValueWithSmartCastInfo? =
@@ -274,7 +274,7 @@ class NewResolutionOldInference(
     }
 
     private inner class SimpleContext<D : CallableDescriptor>(
-            override val scopeTower: ScopeTower,
+            override val scopeTower: ImplicitScopeTower,
             override val name: Name,
             val basicCallContext: BasicCallResolutionContext,
             val tracing: TracingStrategy

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

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValueWithSmartCastInfo
 import org.jetbrains.kotlin.types.KotlinType
 
-interface ScopeTower {
+interface ImplicitScopeTower {
     val lexicalScope: LexicalScope
 
     fun getImplicitReceiver(scope: LexicalScope): ReceiverValueWithSmartCastInfo?

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

@@ -138,7 +138,7 @@ private class InvokeExtensionScopeTowerProcessor<C : Candidate<FunctionDescripto
 }
 
 // todo debug info
-private fun ScopeTower.getExtensionInvokeCandidateDescriptor(
+private fun ImplicitScopeTower.getExtensionInvokeCandidateDescriptor(
         extensionFunctionReceiver: ReceiverValueWithSmartCastInfo
 ): CandidateWithBoundDispatchReceiver<FunctionDescriptor>? {
     val type = extensionFunctionReceiver.receiverValue.type

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

@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
 
 internal abstract class AbstractScopeTowerLevel(
-        protected val scopeTower: ScopeTower
+        protected val scopeTower: ImplicitScopeTower
 ): ScopeTowerLevel {
     protected val location: LookupLocation get() = scopeTower.location
 
@@ -78,7 +78,7 @@ internal abstract class AbstractScopeTowerLevel(
 // todo KT-9538 Unresolved inner class via subclass reference
 // todo add static methods & fields with error
 internal class ReceiverScopeTowerLevel(
-        scopeTower: ScopeTower,
+        scopeTower: ImplicitScopeTower,
         val dispatchReceiver: ReceiverValueWithSmartCastInfo
 ): AbstractScopeTowerLevel(scopeTower) {
 
@@ -147,7 +147,7 @@ internal class ReceiverScopeTowerLevel(
     }
 }
 
-internal class QualifierScopeTowerLevel(scopeTower: ScopeTower, val qualifier: QualifierReceiver) : AbstractScopeTowerLevel(scopeTower) {
+internal class QualifierScopeTowerLevel(scopeTower: ImplicitScopeTower, val qualifier: QualifierReceiver) : AbstractScopeTowerLevel(scopeTower) {
     override fun getVariables(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) = qualifier.staticScope
             .getContributedVariables(name, location).map {
                 createCandidateDescriptor(it, dispatchReceiver = null)
@@ -166,11 +166,11 @@ internal class QualifierScopeTowerLevel(scopeTower: ScopeTower, val qualifier: Q
 
 // KT-3335 Creating imported super class' inner class fails in codegen
 internal open class ScopeBasedTowerLevel protected constructor(
-        scopeTower: ScopeTower,
+        scopeTower: ImplicitScopeTower,
         private val resolutionScope: ResolutionScope
 ) : AbstractScopeTowerLevel(scopeTower) {
 
-    internal constructor(scopeTower: ScopeTower, lexicalScope: LexicalScope): this(scopeTower, lexicalScope as ResolutionScope)
+    internal constructor(scopeTower: ImplicitScopeTower, lexicalScope: LexicalScope): this(scopeTower, lexicalScope as ResolutionScope)
 
     override fun getVariables(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?): Collection<CandidateWithBoundDispatchReceiver<VariableDescriptor>>
             = resolutionScope.getContributedVariables(name, location).map {
@@ -188,12 +188,12 @@ internal open class ScopeBasedTowerLevel protected constructor(
             }
 }
 internal class ImportingScopeBasedTowerLevel(
-        scopeTower: ScopeTower,
+        scopeTower: ImplicitScopeTower,
         importingScope: ImportingScope
 ): ScopeBasedTowerLevel(scopeTower, importingScope)
 
 internal class SyntheticScopeBasedTowerLevel(
-        scopeTower: ScopeTower,
+        scopeTower: ImplicitScopeTower,
         private val syntheticScopes: SyntheticScopes
 ): AbstractScopeTowerLevel(scopeTower) {
     private val ReceiverValueWithSmartCastInfo.allTypes: Set<KotlinType>
@@ -219,7 +219,7 @@ internal class SyntheticScopeBasedTowerLevel(
     }
 }
 
-internal class HidesMembersTowerLevel(scopeTower: ScopeTower): AbstractScopeTowerLevel(scopeTower) {
+internal class HidesMembersTowerLevel(scopeTower: ImplicitScopeTower): AbstractScopeTowerLevel(scopeTower) {
     override fun getVariables(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?)
             = getCandidates(name, extensionReceiver, LexicalScope::collectVariables)
 

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

@@ -40,7 +40,7 @@ interface Candidate<out D : CallableDescriptor> {
 
 interface TowerContext<D : CallableDescriptor, out C: Candidate<D>> {
     val name: Name
-    val scopeTower: ScopeTower
+    val scopeTower: ImplicitScopeTower
 
     fun createCandidate(
             towerCandidate: CandidateWithBoundDispatchReceiver<D>,
@@ -75,18 +75,18 @@ interface ScopeTowerProcessor<out C> {
 
 class TowerResolver {
     fun <C: Candidate<*>> runResolve(
-            scopeTower: ScopeTower,
+            scopeTower: ImplicitScopeTower,
             processor: ScopeTowerProcessor<C>,
             useOrder: Boolean
     ): Collection<C> = scopeTower.run(processor, SuccessfulResultCollector { it.status }, useOrder)
 
     fun <C: Candidate<*>> collectAllCandidates(
-            scopeTower: ScopeTower,
+            scopeTower: ImplicitScopeTower,
             processor: ScopeTowerProcessor<C>
     ): Collection<C>
             = scopeTower.run(processor, AllCandidatesCollector { it.status }, false)
 
-    private fun ScopeTower.createNonLocalLevels(): List<ScopeTowerLevel> {
+    private fun ImplicitScopeTower.createNonLocalLevels(): List<ScopeTowerLevel> {
         val result = ArrayList<ScopeTowerLevel>()
 
         lexicalScope.parentsWithSelf.forEach { scope ->
@@ -103,7 +103,7 @@ class TowerResolver {
         return result
     }
 
-    private fun <C> ScopeTower.run(
+    private fun <C> ImplicitScopeTower.run(
             processor: ScopeTowerProcessor<C>,
             resultCollector: ResultCollector<C>,
             useOrder: Boolean