Rename ScopeTower to ImplicitScopeTower.

2016-08-26 13:59:30 +03:00
parent 0c60cda22a
commit ddb75abe30
5 changed files with 25 additions and 25 deletions
@@ -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
@@ -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?
@@ -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
@@ -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)

@@ -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