From aa5be2ec7b0bf56d2a6dff212fadb15702e5ea17 Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Fri, 26 Aug 2016 14:07:09 +0300 Subject: [PATCH] Refactoring remove scopeTower from TowerContext. --- .../calls/tower/NewResolutionOldInference.kt | 25 +++++++------ .../resolve/calls/tower/InvokeProcessors.kt | 15 ++++---- .../calls/tower/ScopeTowerProcessors.kt | 36 +++++++++++-------- .../resolve/calls/tower/TowerResolver.kt | 1 - 4 files changed, 42 insertions(+), 35 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt index 7f1e2f707d6..81f85254351 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt @@ -77,8 +77,8 @@ class NewResolutionOldInference( outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy, scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext ): ScopeTowerProcessor> { - val functionContext = outer.SimpleContext(scopeTower, name, context, tracing) - return createFunctionProcessor(functionContext, outer.InvokeContext(functionContext), explicitReceiver) + val functionContext = outer.SimpleContext(name, context, tracing) + return createFunctionProcessor(scopeTower, functionContext, outer.InvokeContext(functionContext), explicitReceiver) } } @@ -87,8 +87,8 @@ class NewResolutionOldInference( outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy, scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext ): ScopeTowerProcessor> { - val simpleContext = outer.SimpleContext(scopeTower, name, context, tracing) - return createVariableAndObjectProcessor(simpleContext, explicitReceiver) + val simpleContext = outer.SimpleContext(name, context, tracing) + return createVariableAndObjectProcessor(scopeTower, simpleContext, explicitReceiver) } } @@ -97,11 +97,11 @@ class NewResolutionOldInference( outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy, scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext ): ScopeTowerProcessor> { - val simpleContextF = outer.SimpleContext(scopeTower, name, context, tracing) - val simpleContextV = outer.SimpleContext(scopeTower, name, context, tracing) + val simpleContextF = outer.SimpleContext(name, context, tracing) + val simpleContextV = outer.SimpleContext(name, context, tracing) return CompositeScopeTowerProcessor( - createSimpleFunctionProcessor(simpleContextF, explicitReceiver, classValueReceiver = false), - createVariableProcessor(simpleContextV, explicitReceiver, classValueReceiver = false) + createSimpleFunctionProcessor(scopeTower, simpleContextF, explicitReceiver, classValueReceiver = false), + createVariableProcessor(scopeTower, simpleContextV, explicitReceiver, classValueReceiver = false) ) } } @@ -111,13 +111,13 @@ class NewResolutionOldInference( outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy, scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext ): ScopeTowerProcessor> { - val functionContext = outer.SimpleContext(scopeTower, name, context, tracing) + val functionContext = outer.SimpleContext(name, context, tracing) // todo val call = (context.call as? CallTransformer.CallForImplicitInvoke).sure { "Call should be CallForImplicitInvoke, but it is: ${context.call}" } return createProcessorWithReceiverValueOrEmpty(explicitReceiver) { - createCallTowerProcessorForExplicitInvoke(functionContext, context.transformToReceiverWithSmartCastInfo(call.dispatchReceiver), it) + createCallTowerProcessorForExplicitInvoke(scopeTower, functionContext, context.transformToReceiverWithSmartCastInfo(call.dispatchReceiver), it) } } @@ -274,7 +274,6 @@ class NewResolutionOldInference( } private inner class SimpleContext( - override val scopeTower: ImplicitScopeTower, override val name: Name, val basicCallContext: BasicCallResolutionContext, val tracing: TracingStrategy @@ -351,7 +350,7 @@ class NewResolutionOldInference( val newCall = CallTransformer.stripCallArguments(functionContext.basicCallContext.call).let { if (stripExplicitReceiver) CallTransformer.stripReceiver(it) else it } - return SimpleContext(functionContext.scopeTower, functionContext.name, functionContext.basicCallContext.replaceCall(newCall), functionContext.tracing) + return SimpleContext(functionContext.name, functionContext.basicCallContext.replaceCall(newCall), functionContext.tracing) } override fun contextForInvoke( @@ -387,7 +386,7 @@ class NewResolutionOldInference( .replaceCall(functionCall) .replaceContextDependency(ContextDependency.DEPENDENT) // todo - val newContext = SimpleContext(functionContext.scopeTower, OperatorNameConventions.INVOKE, basicCallResolutionContext, tracingForInvoke) + val newContext = SimpleContext(OperatorNameConventions.INVOKE, basicCallResolutionContext, tracingForInvoke) return basicCallResolutionContext.transformToReceiverWithSmartCastInfo(variableReceiver) to newContext } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/InvokeProcessors.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/InvokeProcessors.kt index dac330ab117..96b440793dc 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/InvokeProcessors.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/InvokeProcessors.kt @@ -86,33 +86,35 @@ abstract class AbstractInvokeTowerProcessor, V // todo KT-9522 Allow invoke convention for synthetic property class InvokeTowerProcessor, V : Candidate>( + val scopeTower: ImplicitScopeTower, invokeContext: InvokeTowerContext, explicitReceiver: DetailedReceiver? ) : AbstractInvokeTowerProcessor( invokeContext, - createVariableAndObjectProcessor(invokeContext.contextForVariable(stripExplicitReceiver = false), explicitReceiver) + createVariableAndObjectProcessor(scopeTower, invokeContext.contextForVariable(stripExplicitReceiver = false), explicitReceiver) ) { // todo filter by operator override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor { val (variableReceiver, invokeContext) = invokeContext.contextForInvoke(variableCandidate, useExplicitReceiver = false) ?: return KnownResultProcessor(emptyList()) - return ExplicitReceiverScopeTowerProcessor(invokeContext, variableReceiver, ScopeTowerLevel::getFunctions) + return ExplicitReceiverScopeTowerProcessor(scopeTower, invokeContext, variableReceiver, ScopeTowerLevel::getFunctions) } } class InvokeExtensionTowerProcessor, V : Candidate>( + val scopeTower: ImplicitScopeTower, invokeContext: InvokeTowerContext, private val explicitReceiver: ReceiverValueWithSmartCastInfo? ) : AbstractInvokeTowerProcessor( invokeContext, - createVariableAndObjectProcessor(invokeContext.contextForVariable(stripExplicitReceiver = true), explicitReceiver = null) + createVariableAndObjectProcessor(scopeTower, invokeContext.contextForVariable(stripExplicitReceiver = true), explicitReceiver = null) ) { override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor { val (variableReceiver, invokeContext) = invokeContext.contextForInvoke(variableCandidate, useExplicitReceiver = true) ?: return KnownResultProcessor(emptyList()) - val invokeDescriptor = invokeContext.scopeTower.getExtensionInvokeCandidateDescriptor(variableReceiver) + val invokeDescriptor = scopeTower.getExtensionInvokeCandidateDescriptor(variableReceiver) ?: return KnownResultProcessor(emptyList()) return InvokeExtensionScopeTowerProcessor(invokeContext, invokeDescriptor, explicitReceiver) } @@ -153,11 +155,12 @@ private fun ImplicitScopeTower.getExtensionInvokeCandidateDescriptor( // case 1.(foo())() or (foo())() fun > createCallTowerProcessorForExplicitInvoke( + scopeTower: ImplicitScopeTower, functionContext: TowerContext, expressionForInvoke: ReceiverValueWithSmartCastInfo, explicitReceiver: ReceiverValueWithSmartCastInfo? ): ScopeTowerProcessor { - val invokeExtensionDescriptor = functionContext.scopeTower.getExtensionInvokeCandidateDescriptor(expressionForInvoke) + val invokeExtensionDescriptor = scopeTower.getExtensionInvokeCandidateDescriptor(expressionForInvoke) if (explicitReceiver != null) { if (invokeExtensionDescriptor == null) { // case 1.(foo())(), where foo() isn't extension function @@ -168,7 +171,7 @@ fun > createCallTowerProcessorForExplicitInvok } } else { - val usualInvoke = ExplicitReceiverScopeTowerProcessor(functionContext, expressionForInvoke, ScopeTowerLevel::getFunctions) // todo operator + val usualInvoke = ExplicitReceiverScopeTowerProcessor(scopeTower, functionContext, expressionForInvoke, ScopeTowerLevel::getFunctions) // todo operator if (invokeExtensionDescriptor == null) { return usualInvoke 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 fbc2264bd28..8d8f8ac71bc 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 @@ -51,6 +51,7 @@ internal abstract class AbstractSimpleScopeTowerProcessor>( + val scopeTower: ImplicitScopeTower, context: TowerContext, val explicitReceiver: ReceiverValueWithSmartCastInfo, val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> @@ -64,7 +65,7 @@ internal class ExplicitReceiverScopeTowerProcessor { - val members = ReceiverScopeTowerLevel(context.scopeTower, explicitReceiver) + val members = ReceiverScopeTowerLevel(scopeTower, explicitReceiver) .collectCandidates(name, null).filter { !it.requiresExtensionReceiver } return members.map { context.createCandidate(it, ExplicitReceiverKind.DISPATCH_RECEIVER, extensionReceiver = null) } } @@ -76,6 +77,7 @@ internal class ExplicitReceiverScopeTowerProcessor>( + val scopeTower: ImplicitScopeTower, context: TowerContext, val qualifier: QualifierReceiver, val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> @@ -83,7 +85,7 @@ private class QualifierScopeTowerProcessor { if (data != TowerData.Empty) return emptyList() - val staticMembers = QualifierScopeTowerLevel(context.scopeTower, qualifier).collectCandidates(name, null) + val staticMembers = QualifierScopeTowerLevel(scopeTower, qualifier).collectCandidates(name, null) .filter { !it.requiresExtensionReceiver } .map { context.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, extensionReceiver = null) } return staticMembers @@ -125,23 +127,24 @@ private class NoExplicitReceiverScopeTowerProcessor> createSimpleProcessor( + scopeTower: ImplicitScopeTower, context: TowerContext, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean, collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> ) : ScopeTowerProcessor { if (explicitReceiver is ReceiverValueWithSmartCastInfo) { - return ExplicitReceiverScopeTowerProcessor(context, explicitReceiver, collectCandidates) + return ExplicitReceiverScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates) } else if (explicitReceiver is QualifierReceiver) { - val qualifierProcessor = QualifierScopeTowerProcessor(context, explicitReceiver, collectCandidates) + val qualifierProcessor = QualifierScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates) if (!classValueReceiver) return qualifierProcessor // todo enum entry, object. val classValue = explicitReceiver.classValueReceiverWithSmartCastInfo ?: return qualifierProcessor return CompositeScopeTowerProcessor( qualifierProcessor, - ExplicitReceiverScopeTowerProcessor(context, classValue, collectCandidates) + ExplicitReceiverScopeTowerProcessor(scopeTower, context, classValue, collectCandidates) ) } else { @@ -152,36 +155,39 @@ private fun > createSimpleProcessor( } } -fun > createVariableProcessor( +fun > createVariableProcessor(scopeTower: ImplicitScopeTower, context: TowerContext, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true -) = createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getVariables) +) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getVariables) -fun > createVariableAndObjectProcessor( +fun > createVariableAndObjectProcessor(scopeTower: ImplicitScopeTower, context: TowerContext, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true ) = CompositeScopeTowerProcessor( - createVariableProcessor(context, explicitReceiver), - createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getObjects) + createVariableProcessor(scopeTower, context, explicitReceiver), + createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getObjects) ) -fun > createSimpleFunctionProcessor( +fun > createSimpleFunctionProcessor(scopeTower: ImplicitScopeTower, context: TowerContext, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true -) = createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getFunctions) +) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getFunctions) fun , V: Candidate> createFunctionProcessor( + scopeTower: ImplicitScopeTower, simpleContext: TowerContext, invokeContext: InvokeTowerContext, explicitReceiver: DetailedReceiver? ): CompositeScopeTowerProcessor { // a.foo() -- simple function call - val simpleFunction = createSimpleFunctionProcessor(simpleContext, explicitReceiver) + val simpleFunction = createSimpleFunctionProcessor(scopeTower, simpleContext, explicitReceiver) // a.foo() -- property a.foo + foo.invoke() - val invokeProcessor = InvokeTowerProcessor(invokeContext, explicitReceiver) + val invokeProcessor = InvokeTowerProcessor(scopeTower, invokeContext, explicitReceiver) // a.foo() -- property foo is extension function with receiver a -- a.invoke() - val invokeExtensionProcessor = createProcessorWithReceiverValueOrEmpty(explicitReceiver) { InvokeExtensionTowerProcessor(invokeContext, it) } + val invokeExtensionProcessor = createProcessorWithReceiverValueOrEmpty(explicitReceiver) { + InvokeExtensionTowerProcessor(scopeTower, invokeContext, it) + } return CompositeScopeTowerProcessor(simpleFunction, invokeProcessor, invokeExtensionProcessor) } 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 63a4b029200..c83479b2d45 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 @@ -40,7 +40,6 @@ interface Candidate { interface TowerContext> { val name: Name - val scopeTower: ImplicitScopeTower fun createCandidate( towerCandidate: CandidateWithBoundDispatchReceiver,