azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring: remove name from ScopeTower.

Browse Source
This commit is contained in:
Stanislav Erokhin
2016-08-26 14:24:22 +03:00
parent aa5be2ec7b
commit c910646eda
4 changed files with 32 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt
+5 -5
View File
@@ -78,7 +78,7 @@ class NewResolutionOldInference(
scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
): ScopeTowerProcessor<MyCandidate<FunctionDescriptor>> {
val functionContext = outer.SimpleContext<FunctionDescriptor>(name, context, tracing)
return createFunctionProcessor(scopeTower, functionContext, outer.InvokeContext(functionContext), explicitReceiver)
return createFunctionProcessor(scopeTower, name, functionContext, outer.InvokeContext(functionContext), explicitReceiver)
}
}
@@ -88,7 +88,7 @@ class NewResolutionOldInference(
scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
): ScopeTowerProcessor<MyCandidate<VariableDescriptor>> {
val simpleContext = outer.SimpleContext<VariableDescriptor>(name, context, tracing)
return createVariableAndObjectProcessor(scopeTower, simpleContext, explicitReceiver)
return createVariableAndObjectProcessor(scopeTower, name, simpleContext, explicitReceiver)
}
}
@@ -100,8 +100,8 @@ class NewResolutionOldInference(
val simpleContextF = outer.SimpleContext<FunctionDescriptor>(name, context, tracing)
val simpleContextV = outer.SimpleContext<VariableDescriptor>(name, context, tracing)
return CompositeScopeTowerProcessor(
createSimpleFunctionProcessor(scopeTower, simpleContextF, explicitReceiver, classValueReceiver = false),
createVariableProcessor(scopeTower, simpleContextV, explicitReceiver, classValueReceiver = false)
createSimpleFunctionProcessor(scopeTower, name, simpleContextF, explicitReceiver, classValueReceiver = false),
createVariableProcessor(scopeTower, name, simpleContextV, explicitReceiver, classValueReceiver = false)
)
}
}
@@ -274,7 +274,7 @@ class NewResolutionOldInference(
}
private inner class SimpleContext<D : CallableDescriptor>(
override val name: Name,
val name: Name,
val basicCallContext: BasicCallResolutionContext,
val tracing: TracingStrategy
) : TowerContext<D, MyCandidate<D>> {
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/InvokeProcessors.kt
+7 -4
View File
@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.tower
import org.jetbrains.kotlin.builtins.isExtensionFunctionType
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.descriptors.VariableDescriptor
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
import org.jetbrains.kotlin.resolve.calls.tasks.createSynthesizedInvokes
import org.jetbrains.kotlin.resolve.scopes.receivers.DetailedReceiver
@@ -87,28 +88,30 @@ abstract class AbstractInvokeTowerProcessor<F : Candidate<FunctionDescriptor>, V
// todo KT-9522 Allow invoke convention for synthetic property
class InvokeTowerProcessor<F : Candidate<FunctionDescriptor>, V : Candidate<VariableDescriptor>>(
val scopeTower: ImplicitScopeTower,
val name: Name,
invokeContext: InvokeTowerContext<F, V>,
explicitReceiver: DetailedReceiver?
) : AbstractInvokeTowerProcessor<F, V>(
invokeContext,
createVariableAndObjectProcessor(scopeTower, invokeContext.contextForVariable(stripExplicitReceiver = false), explicitReceiver)
createVariableAndObjectProcessor(scopeTower, name, invokeContext.contextForVariable(stripExplicitReceiver = false), explicitReceiver)
) {
// todo filter by operator
override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor<F> {
val (variableReceiver, invokeContext) = invokeContext.contextForInvoke(variableCandidate, useExplicitReceiver = false)
?: return KnownResultProcessor(emptyList())
return ExplicitReceiverScopeTowerProcessor(scopeTower, invokeContext, variableReceiver, ScopeTowerLevel::getFunctions)
return ExplicitReceiverScopeTowerProcessor(scopeTower, invokeContext, variableReceiver) { getFunctions(OperatorNameConventions.INVOKE, it) }
}
}
class InvokeExtensionTowerProcessor<F : Candidate<FunctionDescriptor>, V : Candidate<VariableDescriptor>>(
val scopeTower: ImplicitScopeTower,
val name: Name,
invokeContext: InvokeTowerContext<F, V>,
private val explicitReceiver: ReceiverValueWithSmartCastInfo?
) : AbstractInvokeTowerProcessor<F, V>(
invokeContext,
createVariableAndObjectProcessor(scopeTower, invokeContext.contextForVariable(stripExplicitReceiver = true), explicitReceiver = null)
createVariableAndObjectProcessor(scopeTower, name, invokeContext.contextForVariable(stripExplicitReceiver = true), explicitReceiver = null)
) {
override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor<F> {
@@ -171,7 +174,7 @@ fun <F : Candidate<FunctionDescriptor>> createCallTowerProcessorForExplicitInvok
}
}
else {
val usualInvoke = ExplicitReceiverScopeTowerProcessor(scopeTower, functionContext, expressionForInvoke, ScopeTowerLevel::getFunctions) // todo operator
val usualInvoke = ExplicitReceiverScopeTowerProcessor(scopeTower, functionContext, expressionForInvoke) { getFunctions(OperatorNameConventions.INVOKE, it) } // todo operator
if (invokeExtensionDescriptor == null) {
return usualInvoke
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ScopeTowerProcessors.kt
+20 -20
View File
@@ -43,7 +43,6 @@ class CompositeScopeTowerProcessor<out C>(
internal abstract class AbstractSimpleScopeTowerProcessor<D : CallableDescriptor, C: Candidate<D>>(
val context: TowerContext<D, C>
) : ScopeTowerProcessor<C> {
protected val name: Name get() = context.name
protected abstract fun simpleProcess(data: TowerData): Collection<C>
@@ -54,7 +53,7 @@ internal class ExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: Ca
val scopeTower: ImplicitScopeTower,
context: TowerContext<D, C>,
val explicitReceiver: ReceiverValueWithSmartCastInfo,
val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
val collectCandidates: ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
): AbstractSimpleScopeTowerProcessor<D, C>(context) {
override fun simpleProcess(data: TowerData): Collection<C> {
return when (data) {
@@ -66,12 +65,12 @@ internal class ExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: Ca
private fun resolveAsMember(): Collection<C> {
val members = ReceiverScopeTowerLevel(scopeTower, explicitReceiver)
.collectCandidates(name, null).filter { !it.requiresExtensionReceiver }
.collectCandidates(null).filter { !it.requiresExtensionReceiver }
return members.map { context.createCandidate(it, ExplicitReceiverKind.DISPATCH_RECEIVER, extensionReceiver = null) }
}
private fun resolveAsExtension(level: ScopeTowerLevel): Collection<C> {
val extensions = level.collectCandidates(name, explicitReceiver).filter { it.requiresExtensionReceiver }
val extensions = level.collectCandidates(explicitReceiver).filter { it.requiresExtensionReceiver }
return extensions.map { context.createCandidate(it, ExplicitReceiverKind.EXTENSION_RECEIVER, extensionReceiver = explicitReceiver) }
}
}
@@ -80,12 +79,12 @@ private class QualifierScopeTowerProcessor<D : CallableDescriptor, C: Candidate<
val scopeTower: ImplicitScopeTower,
context: TowerContext<D, C>,
val qualifier: QualifierReceiver,
val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
val collectCandidates: ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
): AbstractSimpleScopeTowerProcessor<D, C>(context) {
override fun simpleProcess(data: TowerData): Collection<C> {
if (data != TowerData.Empty) return emptyList()
val staticMembers = QualifierScopeTowerLevel(scopeTower, qualifier).collectCandidates(name, null)
val staticMembers = QualifierScopeTowerLevel(scopeTower, qualifier).collectCandidates(null)
.filter { !it.requiresExtensionReceiver }
.map { context.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, extensionReceiver = null) }
return staticMembers
@@ -94,19 +93,19 @@ private class QualifierScopeTowerProcessor<D : CallableDescriptor, C: Candidate<
private class NoExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: Candidate<D>>(
context: TowerContext<D, C>,
val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
val collectCandidates: ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
) : AbstractSimpleScopeTowerProcessor<D, C>(context) {
override fun simpleProcess(data: TowerData): Collection<C>
= when(data) {
is TowerData.TowerLevel -> {
data.level.collectCandidates(name, null).filter { !it.requiresExtensionReceiver }.map {
data.level.collectCandidates(null).filter { !it.requiresExtensionReceiver }.map {
context.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, extensionReceiver = null)
}
}
is TowerData.BothTowerLevelAndImplicitReceiver -> {
val result = mutableListOf<C>()
data.level.collectCandidates(name, data.implicitReceiver).filter { it.requiresExtensionReceiver }.forEach {
data.level.collectCandidates(data.implicitReceiver).filter { it.requiresExtensionReceiver }.forEach {
result.add(
context.createCandidate(
it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, extensionReceiver = data.implicitReceiver))
@@ -131,7 +130,7 @@ private fun <D : CallableDescriptor, C: Candidate<D>> createSimpleProcessor(
context: TowerContext<D, C>,
explicitReceiver: DetailedReceiver?,
classValueReceiver: Boolean,
collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
collectCandidates: ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
) : ScopeTowerProcessor<C> {
if (explicitReceiver is ReceiverValueWithSmartCastInfo) {
return ExplicitReceiverScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates)
@@ -155,38 +154,39 @@ private fun <D : CallableDescriptor, C: Candidate<D>> createSimpleProcessor(
}
}
fun <C : Candidate<VariableDescriptor>> createVariableProcessor(scopeTower: ImplicitScopeTower,
fun <C : Candidate<VariableDescriptor>> createVariableProcessor(scopeTower: ImplicitScopeTower, name: Name,
context: TowerContext<VariableDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true
) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getVariables)
) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver) { getVariables(name, it) }
fun <C : Candidate<VariableDescriptor>> createVariableAndObjectProcessor(scopeTower: ImplicitScopeTower,
fun <C : Candidate<VariableDescriptor>> createVariableAndObjectProcessor(scopeTower: ImplicitScopeTower, name: Name,
context: TowerContext<VariableDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true
) = CompositeScopeTowerProcessor(
createVariableProcessor(scopeTower, context, explicitReceiver),
createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getObjects)
createVariableProcessor(scopeTower, name, context, explicitReceiver),
createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver) { getObjects(name, it) }
)
fun <C : Candidate<FunctionDescriptor>> createSimpleFunctionProcessor(scopeTower: ImplicitScopeTower,
fun <C : Candidate<FunctionDescriptor>> createSimpleFunctionProcessor(scopeTower: ImplicitScopeTower, name: Name,
context: TowerContext<FunctionDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true
) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getFunctions)
) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver) { getFunctions(name, it) }
fun <F: Candidate<FunctionDescriptor>, V: Candidate<VariableDescriptor>> createFunctionProcessor(
scopeTower: ImplicitScopeTower,
name: Name,
simpleContext: TowerContext<FunctionDescriptor, F>,
invokeContext: InvokeTowerContext<F, V>,
explicitReceiver: DetailedReceiver?
): CompositeScopeTowerProcessor<F> {
// a.foo() -- simple function call
val simpleFunction = createSimpleFunctionProcessor(scopeTower, simpleContext, explicitReceiver)
val simpleFunction = createSimpleFunctionProcessor(scopeTower, name, simpleContext, explicitReceiver)
// a.foo() -- property a.foo + foo.invoke()
val invokeProcessor = InvokeTowerProcessor(scopeTower, invokeContext, explicitReceiver)
val invokeProcessor = InvokeTowerProcessor(scopeTower, name, invokeContext, explicitReceiver)
// a.foo() -- property foo is extension function with receiver a -- a.invoke()
val invokeExtensionProcessor = createProcessorWithReceiverValueOrEmpty(explicitReceiver) {
InvokeExtensionTowerProcessor(scopeTower, invokeContext, it)
InvokeExtensionTowerProcessor(scopeTower, name, invokeContext, it)
}
return CompositeScopeTowerProcessor(simpleFunction, invokeProcessor, invokeExtensionProcessor)
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt
-3
View File
@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.resolve.calls.tower
import org.jetbrains.kotlin.descriptors.CallableDescriptor
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.descriptors.VariableDescriptor
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
import org.jetbrains.kotlin.resolve.scopes.ImportingScope
@@ -39,8 +38,6 @@ interface Candidate<out D : CallableDescriptor> {
}
interface TowerContext<D : CallableDescriptor, out C: Candidate<D>> {
val name: Name
fun createCandidate(
towerCandidate: CandidateWithBoundDispatchReceiver<D>,
explicitReceiverKind: ExplicitReceiverKind,