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

Refactoring remove scopeTower from TowerContext.

Browse Source
This commit is contained in:
Stanislav Erokhin
2016-08-26 14:07:09 +03:00
parent ddb75abe30
commit aa5be2ec7b
4 changed files with 42 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt
+12 -13
View File
@@ -77,8 +77,8 @@ class NewResolutionOldInference(
outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy, outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
): ScopeTowerProcessor<MyCandidate<FunctionDescriptor>> { ): ScopeTowerProcessor<MyCandidate<FunctionDescriptor>> {
val functionContext = outer.SimpleContext<FunctionDescriptor>(scopeTower, name, context, tracing) val functionContext = outer.SimpleContext<FunctionDescriptor>(name, context, tracing)
return createFunctionProcessor(functionContext, outer.InvokeContext(functionContext), explicitReceiver) return createFunctionProcessor(scopeTower, functionContext, outer.InvokeContext(functionContext), explicitReceiver)
} }
} }
@@ -87,8 +87,8 @@ class NewResolutionOldInference(
outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy, outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
): ScopeTowerProcessor<MyCandidate<VariableDescriptor>> { ): ScopeTowerProcessor<MyCandidate<VariableDescriptor>> {
val simpleContext = outer.SimpleContext<VariableDescriptor>(scopeTower, name, context, tracing) val simpleContext = outer.SimpleContext<VariableDescriptor>(name, context, tracing)
return createVariableAndObjectProcessor(simpleContext, explicitReceiver) return createVariableAndObjectProcessor(scopeTower, simpleContext, explicitReceiver)
} }
} }
@@ -97,11 +97,11 @@ class NewResolutionOldInference(
outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy, outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
): ScopeTowerProcessor<MyCandidate<CallableDescriptor>> { ): ScopeTowerProcessor<MyCandidate<CallableDescriptor>> {
val simpleContextF = outer.SimpleContext<FunctionDescriptor>(scopeTower, name, context, tracing) val simpleContextF = outer.SimpleContext<FunctionDescriptor>(name, context, tracing)
val simpleContextV = outer.SimpleContext<VariableDescriptor>(scopeTower, name, context, tracing) val simpleContextV = outer.SimpleContext<VariableDescriptor>(name, context, tracing)
return CompositeScopeTowerProcessor( return CompositeScopeTowerProcessor(
createSimpleFunctionProcessor(simpleContextF, explicitReceiver, classValueReceiver = false), createSimpleFunctionProcessor(scopeTower, simpleContextF, explicitReceiver, classValueReceiver = false),
createVariableProcessor(simpleContextV, explicitReceiver, classValueReceiver = false) createVariableProcessor(scopeTower, simpleContextV, explicitReceiver, classValueReceiver = false)
) )
} }
} }
@@ -111,13 +111,13 @@ class NewResolutionOldInference(
outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy, outer: NewResolutionOldInference, name: Name, tracing: TracingStrategy,
scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext scopeTower: ImplicitScopeTower, explicitReceiver: DetailedReceiver?, context: BasicCallResolutionContext
): ScopeTowerProcessor<MyCandidate<FunctionDescriptor>> { ): ScopeTowerProcessor<MyCandidate<FunctionDescriptor>> {
val functionContext = outer.SimpleContext<FunctionDescriptor>(scopeTower, name, context, tracing) val functionContext = outer.SimpleContext<FunctionDescriptor>(name, context, tracing)
// todo // todo
val call = (context.call as? CallTransformer.CallForImplicitInvoke).sure { val call = (context.call as? CallTransformer.CallForImplicitInvoke).sure {
"Call should be CallForImplicitInvoke, but it is: ${context.call}" "Call should be CallForImplicitInvoke, but it is: ${context.call}"
} }
return createProcessorWithReceiverValueOrEmpty(explicitReceiver) { 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<D : CallableDescriptor>( private inner class SimpleContext<D : CallableDescriptor>(
override val scopeTower: ImplicitScopeTower,
override val name: Name, override val name: Name,
val basicCallContext: BasicCallResolutionContext, val basicCallContext: BasicCallResolutionContext,
val tracing: TracingStrategy val tracing: TracingStrategy
@@ -351,7 +350,7 @@ class NewResolutionOldInference(
val newCall = CallTransformer.stripCallArguments(functionContext.basicCallContext.call).let { val newCall = CallTransformer.stripCallArguments(functionContext.basicCallContext.call).let {
if (stripExplicitReceiver) CallTransformer.stripReceiver(it) else it 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( override fun contextForInvoke(
@@ -387,7 +386,7 @@ class NewResolutionOldInference(
.replaceCall(functionCall) .replaceCall(functionCall)
.replaceContextDependency(ContextDependency.DEPENDENT) // todo .replaceContextDependency(ContextDependency.DEPENDENT) // todo
val newContext = SimpleContext<FunctionDescriptor>(functionContext.scopeTower, OperatorNameConventions.INVOKE, basicCallResolutionContext, tracingForInvoke) val newContext = SimpleContext<FunctionDescriptor>(OperatorNameConventions.INVOKE, basicCallResolutionContext, tracingForInvoke)
return basicCallResolutionContext.transformToReceiverWithSmartCastInfo(variableReceiver) to newContext return basicCallResolutionContext.transformToReceiverWithSmartCastInfo(variableReceiver) to newContext
} }
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/InvokeProcessors.kt
+9 -6
View File
@@ -86,33 +86,35 @@ abstract class AbstractInvokeTowerProcessor<F : Candidate<FunctionDescriptor>, V
// todo KT-9522 Allow invoke convention for synthetic property // todo KT-9522 Allow invoke convention for synthetic property
class InvokeTowerProcessor<F : Candidate<FunctionDescriptor>, V : Candidate<VariableDescriptor>>( class InvokeTowerProcessor<F : Candidate<FunctionDescriptor>, V : Candidate<VariableDescriptor>>(
val scopeTower: ImplicitScopeTower,
invokeContext: InvokeTowerContext<F, V>, invokeContext: InvokeTowerContext<F, V>,
explicitReceiver: DetailedReceiver? explicitReceiver: DetailedReceiver?
) : AbstractInvokeTowerProcessor<F, V>( ) : AbstractInvokeTowerProcessor<F, V>(
invokeContext, invokeContext,
createVariableAndObjectProcessor(invokeContext.contextForVariable(stripExplicitReceiver = false), explicitReceiver) createVariableAndObjectProcessor(scopeTower, invokeContext.contextForVariable(stripExplicitReceiver = false), explicitReceiver)
) { ) {
// todo filter by operator // todo filter by operator
override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor<F> { override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor<F> {
val (variableReceiver, invokeContext) = invokeContext.contextForInvoke(variableCandidate, useExplicitReceiver = false) val (variableReceiver, invokeContext) = invokeContext.contextForInvoke(variableCandidate, useExplicitReceiver = false)
?: return KnownResultProcessor(emptyList()) ?: return KnownResultProcessor(emptyList())
return ExplicitReceiverScopeTowerProcessor(invokeContext, variableReceiver, ScopeTowerLevel::getFunctions) return ExplicitReceiverScopeTowerProcessor(scopeTower, invokeContext, variableReceiver, ScopeTowerLevel::getFunctions)
} }
} }
class InvokeExtensionTowerProcessor<F : Candidate<FunctionDescriptor>, V : Candidate<VariableDescriptor>>( class InvokeExtensionTowerProcessor<F : Candidate<FunctionDescriptor>, V : Candidate<VariableDescriptor>>(
val scopeTower: ImplicitScopeTower,
invokeContext: InvokeTowerContext<F, V>, invokeContext: InvokeTowerContext<F, V>,
private val explicitReceiver: ReceiverValueWithSmartCastInfo? private val explicitReceiver: ReceiverValueWithSmartCastInfo?
) : AbstractInvokeTowerProcessor<F, V>( ) : AbstractInvokeTowerProcessor<F, V>(
invokeContext, invokeContext,
createVariableAndObjectProcessor(invokeContext.contextForVariable(stripExplicitReceiver = true), explicitReceiver = null) createVariableAndObjectProcessor(scopeTower, invokeContext.contextForVariable(stripExplicitReceiver = true), explicitReceiver = null)
) { ) {
override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor<F> { override fun createInvokeProcessor(variableCandidate: V): ScopeTowerProcessor<F> {
val (variableReceiver, invokeContext) = invokeContext.contextForInvoke(variableCandidate, useExplicitReceiver = true) val (variableReceiver, invokeContext) = invokeContext.contextForInvoke(variableCandidate, useExplicitReceiver = true)
?: return KnownResultProcessor(emptyList()) ?: return KnownResultProcessor(emptyList())
val invokeDescriptor = invokeContext.scopeTower.getExtensionInvokeCandidateDescriptor(variableReceiver) val invokeDescriptor = scopeTower.getExtensionInvokeCandidateDescriptor(variableReceiver)
?: return KnownResultProcessor(emptyList()) ?: return KnownResultProcessor(emptyList())
return InvokeExtensionScopeTowerProcessor(invokeContext, invokeDescriptor, explicitReceiver) return InvokeExtensionScopeTowerProcessor(invokeContext, invokeDescriptor, explicitReceiver)
} }
@@ -153,11 +155,12 @@ private fun ImplicitScopeTower.getExtensionInvokeCandidateDescriptor(
// case 1.(foo())() or (foo())() // case 1.(foo())() or (foo())()
fun <F : Candidate<FunctionDescriptor>> createCallTowerProcessorForExplicitInvoke( fun <F : Candidate<FunctionDescriptor>> createCallTowerProcessorForExplicitInvoke(
scopeTower: ImplicitScopeTower,
functionContext: TowerContext<FunctionDescriptor, F>, functionContext: TowerContext<FunctionDescriptor, F>,
expressionForInvoke: ReceiverValueWithSmartCastInfo, expressionForInvoke: ReceiverValueWithSmartCastInfo,
explicitReceiver: ReceiverValueWithSmartCastInfo? explicitReceiver: ReceiverValueWithSmartCastInfo?
): ScopeTowerProcessor<F> { ): ScopeTowerProcessor<F> {
val invokeExtensionDescriptor = functionContext.scopeTower.getExtensionInvokeCandidateDescriptor(expressionForInvoke) val invokeExtensionDescriptor = scopeTower.getExtensionInvokeCandidateDescriptor(expressionForInvoke)
if (explicitReceiver != null) { if (explicitReceiver != null) {
if (invokeExtensionDescriptor == null) { if (invokeExtensionDescriptor == null) {
// case 1.(foo())(), where foo() isn't extension function // case 1.(foo())(), where foo() isn't extension function
@@ -168,7 +171,7 @@ fun <F : Candidate<FunctionDescriptor>> createCallTowerProcessorForExplicitInvok
} }
} }
else { else {
val usualInvoke = ExplicitReceiverScopeTowerProcessor(functionContext, expressionForInvoke, ScopeTowerLevel::getFunctions) // todo operator val usualInvoke = ExplicitReceiverScopeTowerProcessor(scopeTower, functionContext, expressionForInvoke, ScopeTowerLevel::getFunctions) // todo operator
if (invokeExtensionDescriptor == null) { if (invokeExtensionDescriptor == null) {
return usualInvoke return usualInvoke
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ScopeTowerProcessors.kt
+21 -15
View File
@@ -51,6 +51,7 @@ internal abstract class AbstractSimpleScopeTowerProcessor<D : CallableDescriptor
} }
internal class ExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: Candidate<D>>( internal class ExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: Candidate<D>>(
val scopeTower: ImplicitScopeTower,
context: TowerContext<D, C>, context: TowerContext<D, C>,
val explicitReceiver: ReceiverValueWithSmartCastInfo, val explicitReceiver: ReceiverValueWithSmartCastInfo,
val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>> val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
@@ -64,7 +65,7 @@ internal class ExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: Ca
} }
private fun resolveAsMember(): Collection<C> { private fun resolveAsMember(): Collection<C> {
val members = ReceiverScopeTowerLevel(context.scopeTower, explicitReceiver) val members = ReceiverScopeTowerLevel(scopeTower, explicitReceiver)
.collectCandidates(name, null).filter { !it.requiresExtensionReceiver } .collectCandidates(name, null).filter { !it.requiresExtensionReceiver }
return members.map { context.createCandidate(it, ExplicitReceiverKind.DISPATCH_RECEIVER, extensionReceiver = null) } return members.map { context.createCandidate(it, ExplicitReceiverKind.DISPATCH_RECEIVER, extensionReceiver = null) }
} }
@@ -76,6 +77,7 @@ internal class ExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: Ca
} }
private class QualifierScopeTowerProcessor<D : CallableDescriptor, C: Candidate<D>>( private class QualifierScopeTowerProcessor<D : CallableDescriptor, C: Candidate<D>>(
val scopeTower: ImplicitScopeTower,
context: TowerContext<D, C>, context: TowerContext<D, C>,
val qualifier: QualifierReceiver, val qualifier: QualifierReceiver,
val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>> val collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
@@ -83,7 +85,7 @@ private class QualifierScopeTowerProcessor<D : CallableDescriptor, C: Candidate<
override fun simpleProcess(data: TowerData): Collection<C> { override fun simpleProcess(data: TowerData): Collection<C> {
if (data != TowerData.Empty) return emptyList() 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 } .filter { !it.requiresExtensionReceiver }
.map { context.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, extensionReceiver = null) } .map { context.createCandidate(it, ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, extensionReceiver = null) }
return staticMembers return staticMembers
@@ -125,23 +127,24 @@ private class NoExplicitReceiverScopeTowerProcessor<D : CallableDescriptor, C: C
} }
private fun <D : CallableDescriptor, C: Candidate<D>> createSimpleProcessor( private fun <D : CallableDescriptor, C: Candidate<D>> createSimpleProcessor(
scopeTower: ImplicitScopeTower,
context: TowerContext<D, C>, context: TowerContext<D, C>,
explicitReceiver: DetailedReceiver?, explicitReceiver: DetailedReceiver?,
classValueReceiver: Boolean, classValueReceiver: Boolean,
collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>> collectCandidates: ScopeTowerLevel.(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) -> Collection<CandidateWithBoundDispatchReceiver<D>>
) : ScopeTowerProcessor<C> { ) : ScopeTowerProcessor<C> {
if (explicitReceiver is ReceiverValueWithSmartCastInfo) { if (explicitReceiver is ReceiverValueWithSmartCastInfo) {
return ExplicitReceiverScopeTowerProcessor(context, explicitReceiver, collectCandidates) return ExplicitReceiverScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates)
} }
else if (explicitReceiver is QualifierReceiver) { else if (explicitReceiver is QualifierReceiver) {
val qualifierProcessor = QualifierScopeTowerProcessor(context, explicitReceiver, collectCandidates) val qualifierProcessor = QualifierScopeTowerProcessor(scopeTower, context, explicitReceiver, collectCandidates)
if (!classValueReceiver) return qualifierProcessor if (!classValueReceiver) return qualifierProcessor
// todo enum entry, object. // todo enum entry, object.
val classValue = explicitReceiver.classValueReceiverWithSmartCastInfo ?: return qualifierProcessor val classValue = explicitReceiver.classValueReceiverWithSmartCastInfo ?: return qualifierProcessor
return CompositeScopeTowerProcessor( return CompositeScopeTowerProcessor(
qualifierProcessor, qualifierProcessor,
ExplicitReceiverScopeTowerProcessor(context, classValue, collectCandidates) ExplicitReceiverScopeTowerProcessor(scopeTower, context, classValue, collectCandidates)
) )
} }
else { else {
@@ -152,36 +155,39 @@ private fun <D : CallableDescriptor, C: Candidate<D>> createSimpleProcessor(
} }
} }
fun <C : Candidate<VariableDescriptor>> createVariableProcessor( fun <C : Candidate<VariableDescriptor>> createVariableProcessor(scopeTower: ImplicitScopeTower,
context: TowerContext<VariableDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true context: TowerContext<VariableDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true
) = createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getVariables) ) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getVariables)
fun <C : Candidate<VariableDescriptor>> createVariableAndObjectProcessor( fun <C : Candidate<VariableDescriptor>> createVariableAndObjectProcessor(scopeTower: ImplicitScopeTower,
context: TowerContext<VariableDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true context: TowerContext<VariableDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true
) = CompositeScopeTowerProcessor( ) = CompositeScopeTowerProcessor(
createVariableProcessor(context, explicitReceiver), createVariableProcessor(scopeTower, context, explicitReceiver),
createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getObjects) createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getObjects)
) )
fun <C : Candidate<FunctionDescriptor>> createSimpleFunctionProcessor( fun <C : Candidate<FunctionDescriptor>> createSimpleFunctionProcessor(scopeTower: ImplicitScopeTower,
context: TowerContext<FunctionDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true context: TowerContext<FunctionDescriptor, C>, explicitReceiver: DetailedReceiver?, classValueReceiver: Boolean = true
) = createSimpleProcessor(context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getFunctions) ) = createSimpleProcessor(scopeTower, context, explicitReceiver, classValueReceiver, ScopeTowerLevel::getFunctions)
fun <F: Candidate<FunctionDescriptor>, V: Candidate<VariableDescriptor>> createFunctionProcessor( fun <F: Candidate<FunctionDescriptor>, V: Candidate<VariableDescriptor>> createFunctionProcessor(
scopeTower: ImplicitScopeTower,
simpleContext: TowerContext<FunctionDescriptor, F>, simpleContext: TowerContext<FunctionDescriptor, F>,
invokeContext: InvokeTowerContext<F, V>, invokeContext: InvokeTowerContext<F, V>,
explicitReceiver: DetailedReceiver? explicitReceiver: DetailedReceiver?
): CompositeScopeTowerProcessor<F> { ): CompositeScopeTowerProcessor<F> {
// a.foo() -- simple function call // a.foo() -- simple function call
val simpleFunction = createSimpleFunctionProcessor(simpleContext, explicitReceiver) val simpleFunction = createSimpleFunctionProcessor(scopeTower, simpleContext, explicitReceiver)
// a.foo() -- property a.foo + foo.invoke() // 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() // 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) return CompositeScopeTowerProcessor(simpleFunction, invokeProcessor, invokeExtensionProcessor)
} }
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt
-1
View File
@@ -40,7 +40,6 @@ interface Candidate<out D : CallableDescriptor> {
interface TowerContext<D : CallableDescriptor, out C: Candidate<D>> { interface TowerContext<D : CallableDescriptor, out C: Candidate<D>> {
val name: Name val name: Name
val scopeTower: ImplicitScopeTower
fun createCandidate( fun createCandidate(
towerCandidate: CandidateWithBoundDispatchReceiver<D>, towerCandidate: CandidateWithBoundDispatchReceiver<D>,