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 81f85254351..0ff062f1532 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 @@ -78,7 +78,7 @@ class NewResolutionOldInference( scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext ): ScopeTowerProcessor> { val functionContext = outer.SimpleContext(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> { val simpleContext = outer.SimpleContext(name, context, tracing) - return createVariableAndObjectProcessor(scopeTower, simpleContext, explicitReceiver) + return createVariableAndObjectProcessor(scopeTower, name, simpleContext, explicitReceiver) } } @@ -100,8 +100,8 @@ class NewResolutionOldInference( val simpleContextF = outer.SimpleContext(name, context, tracing) val simpleContextV = outer.SimpleContext(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( - override val name: Name, + val name: Name, val basicCallContext: BasicCallResolutionContext, val tracing: TracingStrategy ) : TowerContext> { 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 96b440793dc..30997ac0bbe 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 @@ -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, V // todo KT-9522 Allow invoke convention for synthetic property class InvokeTowerProcessor, V : Candidate>( val scopeTower: ImplicitScopeTower, + val name: Name, invokeContext: InvokeTowerContext, explicitReceiver: DetailedReceiver? ) : AbstractInvokeTowerProcessor( 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 { 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, V : Candidate>( val scopeTower: ImplicitScopeTower, + val name: Name, invokeContext: InvokeTowerContext, private val explicitReceiver: ReceiverValueWithSmartCastInfo? ) : AbstractInvokeTowerProcessor( invokeContext, - createVariableAndObjectProcessor(scopeTower, invokeContext.contextForVariable(stripExplicitReceiver = true), explicitReceiver = null) + createVariableAndObjectProcessor(scopeTower, name, invokeContext.contextForVariable(stripExplicitReceiver = true), explicitReceiver = null) ) { override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor { @@ -171,7 +174,7 @@ fun > 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 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 8d8f8ac71bc..d67599ffa25 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 @@ -43,7 +43,6 @@ class CompositeScopeTowerProcessor( internal abstract class AbstractSimpleScopeTowerProcessor>( val context: TowerContext ) : ScopeTowerProcessor { - protected val name: Name get() = context.name protected abstract fun simpleProcess(data: TowerData): Collection @@ -54,7 +53,7 @@ internal class ExplicitReceiverScopeTowerProcessor, val explicitReceiver: ReceiverValueWithSmartCastInfo, - val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> + val collectCandidates: ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> ): AbstractSimpleScopeTowerProcessor(context) { override fun simpleProcess(data: TowerData): Collection { return when (data) { @@ -66,12 +65,12 @@ internal class ExplicitReceiverScopeTowerProcessor { 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 { - 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, val qualifier: QualifierReceiver, - val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> + val collectCandidates: ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> ): AbstractSimpleScopeTowerProcessor(context) { override fun simpleProcess(data: TowerData): Collection { 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>( context: TowerContext, - val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> + val collectCandidates: ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> ) : AbstractSimpleScopeTowerProcessor(context) { override fun simpleProcess(data: TowerData): Collection = 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() - 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 > createSimpleProcessor( context: TowerContext, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean, - collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> + collectCandidates: ScopeTowerLevel.(extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection> ) : ScopeTowerProcessor { if (explicitReceiver is ReceiverValueWithSmartCastInfo) { return ExplicitReceiverScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates) @@ -155,38 +154,39 @@ private fun > createSimpleProcessor( } } -fun > createVariableProcessor(scopeTower: ImplicitScopeTower, +fun > createVariableProcessor(scopeTower: ImplicitScopeTower, name: Name, context: TowerContext, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true -) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getVariables) +) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver) { getVariables(name, it) } -fun > createVariableAndObjectProcessor(scopeTower: ImplicitScopeTower, +fun > createVariableAndObjectProcessor(scopeTower: ImplicitScopeTower, name: Name, context: TowerContext, 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 > createSimpleFunctionProcessor(scopeTower: ImplicitScopeTower, +fun > createSimpleFunctionProcessor(scopeTower: ImplicitScopeTower, name: Name, context: TowerContext, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true -) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getFunctions) +) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver) { getFunctions(name, it) } fun , V: Candidate> createFunctionProcessor( scopeTower: ImplicitScopeTower, + name: Name, simpleContext: TowerContext, invokeContext: InvokeTowerContext, explicitReceiver: DetailedReceiver? ): CompositeScopeTowerProcessor { // 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) 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 c83479b2d45..998e9df5a27 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 @@ -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 { } interface TowerContext> { - val name: Name - fun createCandidate( towerCandidate: CandidateWithBoundDispatchReceiver, explicitReceiverKind: ExplicitReceiverKind,