From 09250c89ed666d8abd59e0dfaa9ff1f022e061dc Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Mon, 1 Dec 2014 21:17:42 +0300 Subject: [PATCH] Convert TaskPrioritizer to kotlin. --- .../jet/lang/resolve/calls/CallResolver.java | 2 +- .../lang/resolve/calls/CandidateResolver.java | 15 +- .../resolve/calls/tasks/TaskPrioritizer.java | 691 ++++++++---------- 3 files changed, 324 insertions(+), 384 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 3c83a83d824..630308bcbba 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -263,7 +263,7 @@ public class CallResolver { return checkArgumentTypesAndFail(context); } Collection> candidates = - TaskPrioritizer.convertWithImpliedThisAndNoReceiver( + taskPrioritizer.convertWithImpliedThisAndNoReceiver( context.scope, constructors, context.call); prioritizedTasks = taskPrioritizer.computePrioritizedTasksFromCandidates( context, candidates, TracingStrategyImpl.create(functionReference, context.call)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java index 2d8afdc3079..ffc252f4f69 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java @@ -38,7 +38,6 @@ import org.jetbrains.jet.lang.resolve.calls.smartcasts.DataFlowValue; import org.jetbrains.jet.lang.resolve.calls.smartcasts.DataFlowValueFactory; import org.jetbrains.jet.lang.resolve.calls.smartcasts.SmartCastUtils; import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionTask; -import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; import org.jetbrains.jet.lang.resolve.calls.util.FakeCallableDescriptorForObject; import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; @@ -163,7 +162,7 @@ public class CandidateResolver { // 'super' cannot be passed as an argument, for receiver arguments expression typer does not track this // See TaskPrioritizer for more - JetSuperExpression superExpression = TaskPrioritizer.getReceiverSuper(candidateCall.getExtensionReceiver()); + JetSuperExpression superExpression = getReceiverSuper(candidateCall.getExtensionReceiver()); if (superExpression != null) { context.trace.report(SUPER_IS_NOT_AN_EXPRESSION.on(superExpression, superExpression.getText())); candidateCall.addStatus(OTHER_ERROR); @@ -205,6 +204,18 @@ public class CandidateResolver { return DescriptorResolver.checkHasOuterClassInstance(context.scope, context.trace, context.call.getCallElement(), candidateThis); } + @Nullable + private static JetSuperExpression getReceiverSuper(@NotNull ReceiverValue receiver) { + if (receiver instanceof ExpressionReceiver) { + ExpressionReceiver expressionReceiver = (ExpressionReceiver) receiver; + JetExpression expression = expressionReceiver.getExpression(); + if (expression instanceof JetSuperExpression) { + return (JetSuperExpression) expression; + } + } + return null; + } + @Nullable private static ClassDescriptor getDeclaringClass(@NotNull CallableDescriptor candidate) { ReceiverParameterDescriptor expectedThis = candidate.getDispatchReceiverParameter(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java index 733812c97cd..c769d557767 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,310 +14,270 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.resolve.calls.tasks; +package org.jetbrains.jet.lang.resolve.calls.tasks -import com.google.common.collect.Lists; -import com.google.common.collect.Sets; -import com.intellij.openapi.progress.ProgressIndicatorProvider; -import kotlin.Function0; -import kotlin.Function1; -import kotlin.KotlinPackage; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.psi.Call; -import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetSuperExpression; -import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext; -import org.jetbrains.jet.lang.resolve.calls.smartcasts.SmartCastUtils; -import org.jetbrains.jet.lang.resolve.calls.tasks.collectors.CallableDescriptorCollector; -import org.jetbrains.jet.lang.resolve.calls.tasks.collectors.CallableDescriptorCollectors; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils; -import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; -import org.jetbrains.jet.lang.resolve.scopes.receivers.QualifierReceiver; -import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; -import org.jetbrains.jet.lang.types.ErrorUtils; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypesPackage; -import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; -import org.jetbrains.jet.storage.StorageManager; +import com.google.common.collect.Lists +import com.google.common.collect.Sets +import com.intellij.openapi.progress.ProgressIndicatorProvider +import kotlin.Function0 +import kotlin.Function1 +import org.jetbrains.jet.lang.descriptors.* +import org.jetbrains.jet.lang.psi.Call +import org.jetbrains.jet.lang.psi.JetExpression +import org.jetbrains.jet.lang.psi.JetSuperExpression +import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext +import org.jetbrains.jet.lang.resolve.calls.smartcasts.SmartCastUtils +import org.jetbrains.jet.lang.resolve.calls.tasks.collectors.CallableDescriptorCollector +import org.jetbrains.jet.lang.resolve.calls.tasks.collectors.CallableDescriptorCollectors +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.lang.resolve.scopes.JetScope +import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils +import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver +import org.jetbrains.jet.lang.resolve.scopes.receivers.QualifierReceiver +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue +import org.jetbrains.jet.lang.types.ErrorUtils +import org.jetbrains.jet.lang.types.JetType +import org.jetbrains.jet.lang.types.* +import org.jetbrains.jet.lang.types.checker.JetTypeChecker +import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils +import org.jetbrains.jet.storage.StorageManager +import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; +import java.util.ArrayList -import static org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.isOrOverridesSynthesized; -import static org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind.*; -import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER; +import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.isOrOverridesSynthesized +import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind.* +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue.NO_RECEIVER -public class TaskPrioritizer { +public class TaskPrioritizer(private val storageManager: StorageManager) { - @NotNull - private final StorageManager storageManager; - - public TaskPrioritizer(@NotNull StorageManager manager) { - storageManager = manager; - } - - public static void splitLexicallyLocalDescriptors( - @NotNull Collection> allDescriptors, - @NotNull DeclarationDescriptor containerOfTheCurrentLocality, - @NotNull Collection> local, - @NotNull Collection> nonlocal + public fun splitLexicallyLocalDescriptors( + allDescriptors: Collection>, + containerOfTheCurrentLocality: DeclarationDescriptor, + local: MutableCollection>, + nonlocal: MutableCollection> ) { - for (ResolutionCandidate resolvedCall : allDescriptors) { + for (resolvedCall in allDescriptors) { if (ExpressionTypingUtils.isLocal(containerOfTheCurrentLocality, resolvedCall.getDescriptor())) { - local.add(resolvedCall); + local.add(resolvedCall) } else { - nonlocal.add(resolvedCall); + nonlocal.add(resolvedCall) } } } - @Nullable - public static JetSuperExpression getReceiverSuper(@NotNull ReceiverValue receiver) { - if (receiver instanceof ExpressionReceiver) { - ExpressionReceiver expressionReceiver = (ExpressionReceiver) receiver; - JetExpression expression = expressionReceiver.getExpression(); - if (expression instanceof JetSuperExpression) { - return (JetSuperExpression) expression; - } - } - return null; - } + public fun computePrioritizedTasks( + context: BasicCallResolutionContext, + name: Name, + tracing: TracingStrategy, + callableDescriptorCollectors: CallableDescriptorCollectors + ): List> { + val explicitReceiver = context.call.getExplicitReceiver() + val result = ResolutionTaskHolder(storageManager, context, MyPriorityProvider(context), tracing) + val taskPrioritizerContext = TaskPrioritizerContext(name, result, context, context.scope, callableDescriptorCollectors) - @NotNull - public List> computePrioritizedTasks( - @NotNull BasicCallResolutionContext context, - @NotNull Name name, - @NotNull TracingStrategy tracing, - @NotNull CallableDescriptorCollectors callableDescriptorCollectors - ) { - ReceiverValue explicitReceiver = context.call.getExplicitReceiver(); - ResolutionTaskHolder result = - new ResolutionTaskHolder(storageManager, context, new MyPriorityProvider(context), tracing); - TaskPrioritizerContext taskPrioritizerContext = - new TaskPrioritizerContext(name, result, context, context.scope, callableDescriptorCollectors); - - if (explicitReceiver instanceof QualifierReceiver) { - QualifierReceiver qualifierReceiver = (QualifierReceiver) explicitReceiver; - doComputeTasks(NO_RECEIVER, taskPrioritizerContext.replaceScope(qualifierReceiver.getNestedClassesAndPackageMembersScope())); - ReceiverValue classObjectReceiver = qualifierReceiver.getClassObjectReceiver(); + if (explicitReceiver is QualifierReceiver) { + val qualifierReceiver = explicitReceiver : QualifierReceiver + doComputeTasks(NO_RECEIVER, taskPrioritizerContext.replaceScope(qualifierReceiver.getNestedClassesAndPackageMembersScope())) + val classObjectReceiver = qualifierReceiver.getClassObjectReceiver() if (classObjectReceiver.exists()) { - doComputeTasks(classObjectReceiver, taskPrioritizerContext); + doComputeTasks(classObjectReceiver, taskPrioritizerContext) } } else { - doComputeTasks(explicitReceiver, taskPrioritizerContext); + doComputeTasks(explicitReceiver, taskPrioritizerContext) } - return result.getTasks(); + return result.getTasks() } - private static void doComputeTasks( - @NotNull ReceiverValue receiver, - @NotNull TaskPrioritizerContext c - ) { - ProgressIndicatorProvider.checkCanceled(); + private fun doComputeTasks(receiver: ReceiverValue, c: TaskPrioritizerContext) { + ProgressIndicatorProvider.checkCanceled() - boolean resolveInvoke = c.context.call.getDispatchReceiver().exists(); + val resolveInvoke = c.context.call.getDispatchReceiver().exists() if (resolveInvoke) { - addCandidatesForInvoke(receiver, c); - return; + addCandidatesForInvoke(receiver, c) + return } - Collection implicitReceivers = Sets.newLinkedHashSet(JetScopeUtils.getImplicitReceiversHierarchyValues(c.scope)); + val implicitReceivers = Sets.newLinkedHashSet(JetScopeUtils.getImplicitReceiversHierarchyValues(c.scope)) if (receiver.exists()) { - addCandidatesForExplicitReceiver(receiver, implicitReceivers, c, /*isExplicit=*/true); - addMembers(receiver, c, /*static=*/true, /*isExplicit=*/true); - return; + addCandidatesForExplicitReceiver(receiver, implicitReceivers, c, isExplicit = true) + addMembers(receiver, c, staticMembers = true, isExplicit = true) + return } - addCandidatesForNoReceiver(implicitReceivers, c); + addCandidatesForNoReceiver(implicitReceivers, c) } - private static void addCandidatesForExplicitReceiver( - @NotNull ReceiverValue explicitReceiver, - @NotNull Collection implicitReceivers, - @NotNull TaskPrioritizerContext c, - boolean isExplicit + private fun addCandidatesForExplicitReceiver( + explicitReceiver: ReceiverValue, + implicitReceivers: Collection, + c: TaskPrioritizerContext, + isExplicit: Boolean ) { - addMembers(explicitReceiver, c, /*static=*/false, isExplicit); + addMembers(explicitReceiver, c, staticMembers = false, isExplicit = isExplicit) - if (TypesPackage.isDynamic(explicitReceiver.getType())) { - addCandidatesForDynamicReceiver(explicitReceiver, implicitReceivers, c, isExplicit); + if (explicitReceiver.getType().isDynamic()) { + addCandidatesForDynamicReceiver(explicitReceiver, implicitReceivers, c, isExplicit) } else { - addExtensionCandidates(explicitReceiver, implicitReceivers, c, isExplicit); + addExtensionCandidates(explicitReceiver, implicitReceivers, c, isExplicit) } } - private static void addExtensionCandidates( - @NotNull final ReceiverValue explicitReceiver, - @NotNull Collection implicitReceivers, - @NotNull final TaskPrioritizerContext c, - final boolean isExplicit + private fun addExtensionCandidates( + explicitReceiver: ReceiverValue, + implicitReceivers: Collection, + c: TaskPrioritizerContext, + isExplicit: Boolean ) { - for (final CallableDescriptorCollector callableDescriptorCollector : c.callableDescriptorCollectors) { + for (callableDescriptorCollector in c.callableDescriptorCollectors) { //member extensions - for (ReceiverValue implicitReceiver : implicitReceivers) { - addMemberExtensionCandidates(implicitReceiver, explicitReceiver, - callableDescriptorCollector, c, createKind(EXTENSION_RECEIVER, isExplicit)); + for (implicitReceiver in implicitReceivers) { + addMemberExtensionCandidates( + implicitReceiver, + explicitReceiver, + callableDescriptorCollector, + c, + createKind(EXTENSION_RECEIVER, isExplicit) + ) } //extensions - c.result.addCandidates(new Function0>>() { - @Override - public Collection> invoke() { - return convertWithImpliedThis( - c.scope, explicitReceiver, callableDescriptorCollector.getExtensionsByName(c.scope, c.name, c.context.trace), - createKind(EXTENSION_RECEIVER, isExplicit), c.context.call); - } - }); - } - } - - private static void addMembers( - final ReceiverValue explicitReceiver, - final TaskPrioritizerContext c, - final boolean staticMembers, - final boolean isExplicit - ) { - for (final CallableDescriptorCollector callableDescriptorCollector : c.callableDescriptorCollectors) { - c.result.addCandidates(new Function0>>() { - @Override - public Collection> invoke() { - List variantsForExplicitReceiver = SmartCastUtils.getSmartCastVariants(explicitReceiver, c.context); - Collection> members = Lists.newArrayList(); - for (JetType type : variantsForExplicitReceiver) { - Collection membersForThisVariant = - staticMembers - ? callableDescriptorCollector.getStaticMembersByName(type, c.name, c.context.trace) - : callableDescriptorCollector.getMembersByName(type, c.name, c.context.trace); - convertWithReceivers(membersForThisVariant, explicitReceiver, - NO_RECEIVER, members, createKind(DISPATCH_RECEIVER, isExplicit), c.context.call); - } - return members; - } - }); - } - } - - private static void addCandidatesForDynamicReceiver( - @NotNull final ReceiverValue explicitReceiver, - @NotNull Collection implicitReceivers, - @NotNull final TaskPrioritizerContext c, - boolean isExplicit - ) { - TaskPrioritizerContext onlyDynamicReceivers = c.replaceCollectors(TasksPackage.onlyDynamicReceivers(c.callableDescriptorCollectors)); - addExtensionCandidates(explicitReceiver, implicitReceivers, onlyDynamicReceivers, isExplicit); - - c.result.addCandidates( - new Function0>>() { - @Override - public Collection> invoke() { - - JetScope dynamicScope = DynamicCallableDescriptors.createDynamicDescriptorScope( - c.context.call, - c.scope.getContainingDeclaration() - ); - - Collection dynamicDescriptors = new ArrayList(); - for (CallableDescriptorCollector collector : c.callableDescriptorCollectors) { - dynamicDescriptors.addAll(collector.getNonExtensionsByName(dynamicScope, c.name, c.context.trace)); - } - - return KotlinPackage.map( - dynamicDescriptors, - new Function1>() { - @Override - public ResolutionCandidate invoke(D dynamicDescriptor) { - ResolutionCandidate dynamicCandidate = ResolutionCandidate.create( - c.context.call, - dynamicDescriptor - ); - dynamicCandidate.setDispatchReceiver(explicitReceiver); - dynamicCandidate.setExplicitReceiverKind(DISPATCH_RECEIVER); - return dynamicCandidate; - } - } - ); - } - } - ); - } - - private static ExplicitReceiverKind createKind(ExplicitReceiverKind kind, boolean isExplicit) { - if (isExplicit) return kind; - return ExplicitReceiverKind.NO_EXPLICIT_RECEIVER; - } - - private static void addMemberExtensionCandidates( - @NotNull final ReceiverValue dispatchReceiver, - @NotNull final ReceiverValue receiverParameter, - @NotNull final CallableDescriptorCollector callableDescriptorCollector, - @NotNull final TaskPrioritizerContext c, - @NotNull final ExplicitReceiverKind receiverKind - ) { - c.result.addCandidates(new Function0>>() { - @Override - public Collection> invoke() { - Collection memberExtensions = callableDescriptorCollector.getExtensionsByName( - dispatchReceiver.getType().getMemberScope(), c.name, c.context.trace); - return convertWithReceivers( - memberExtensions, dispatchReceiver, receiverParameter, receiverKind, c.context.call); + c.result.addCandidates { + convertWithImpliedThis( + c.scope, + explicitReceiver, + callableDescriptorCollector.getExtensionsByName(c.scope, c.name, c.context.trace), + createKind(EXTENSION_RECEIVER, isExplicit), + c.context.call + ) } - }); + } } - private static void addCandidatesForNoReceiver( - @NotNull Collection implicitReceivers, - @NotNull TaskPrioritizerContext c + private fun addMembers( + explicitReceiver: ReceiverValue, + c: TaskPrioritizerContext, + staticMembers: Boolean, + isExplicit: Boolean ) { - List>> localsList = Lists.newArrayList(); - List>> nonlocalsList = Lists.newArrayList(); - for (CallableDescriptorCollector callableDescriptorCollector : c.callableDescriptorCollectors) { + for (callableDescriptorCollector in c.callableDescriptorCollectors) { + c.result.addCandidates { + val variantsForExplicitReceiver = SmartCastUtils.getSmartCastVariants(explicitReceiver, c.context as ResolutionContext<*>) //workaround KT-1969 + val members = Lists.newArrayList>() + for (type in variantsForExplicitReceiver) { + val membersForThisVariant = if (staticMembers) { + callableDescriptorCollector.getStaticMembersByName(type, c.name, c.context.trace) + } + else { + callableDescriptorCollector.getMembersByName(type, c.name, c.context.trace) + } + convertWithReceivers( + membersForThisVariant, + explicitReceiver, + NO_RECEIVER, + members, + createKind(DISPATCH_RECEIVER, isExplicit), + c.context.call + ) + } + members + } + } + } - Collection> members = convertWithImpliedThisAndNoReceiver( - c.scope, callableDescriptorCollector.getNonExtensionsByName(c.scope, c.name, c.context.trace), c.context.call); + private fun addCandidatesForDynamicReceiver( + explicitReceiver: ReceiverValue, + implicitReceivers: Collection, + c: TaskPrioritizerContext, + isExplicit: Boolean + ) { + val onlyDynamicReceivers = c.replaceCollectors(c.callableDescriptorCollectors.onlyDynamicReceivers()) + addExtensionCandidates(explicitReceiver, implicitReceivers, onlyDynamicReceivers, isExplicit) - List> nonlocals = Lists.newArrayList(); - List> locals = Lists.newArrayList(); + c.result.addCandidates { + val dynamicScope = DynamicCallableDescriptors.createDynamicDescriptorScope(c.context.call, c.scope.getContainingDeclaration()) + + val dynamicDescriptors = ArrayList() + for (collector in c.callableDescriptorCollectors) { + dynamicDescriptors.addAll(collector.getNonExtensionsByName(dynamicScope, c.name, c.context.trace)) + } + + dynamicDescriptors.map { + val dynamicCandidate = ResolutionCandidate.create(c.context.call, it) + dynamicCandidate.setDispatchReceiver(explicitReceiver) + dynamicCandidate.setExplicitReceiverKind(DISPATCH_RECEIVER) + dynamicCandidate + } + } + } + + private fun createKind(kind: ExplicitReceiverKind, isExplicit: Boolean): ExplicitReceiverKind { + if (isExplicit) return kind + return ExplicitReceiverKind.NO_EXPLICIT_RECEIVER + } + + private fun addMemberExtensionCandidates( + dispatchReceiver: ReceiverValue, + receiverParameter: ReceiverValue, + callableDescriptorCollector: CallableDescriptorCollector, + c: TaskPrioritizerContext, + receiverKind: ExplicitReceiverKind + ) { + c.result.addCandidates { + val memberExtensions = + callableDescriptorCollector.getExtensionsByName(dispatchReceiver.getType().getMemberScope(), c.name, c.context.trace) + convertWithReceivers(memberExtensions, dispatchReceiver, receiverParameter, receiverKind, c.context.call) + } + } + + private fun addCandidatesForNoReceiver( + implicitReceivers: Collection, + c: TaskPrioritizerContext + ) { + val localsList = Lists.newArrayList>>() + val nonlocalsList = Lists.newArrayList>>() + for (callableDescriptorCollector in c.callableDescriptorCollectors) { + + val members = convertWithImpliedThisAndNoReceiver( + c.scope, + callableDescriptorCollector.getNonExtensionsByName(c.scope, c.name, c.context.trace), + c.context.call + ) + + val nonlocals = Lists.newArrayList>() + val locals = Lists.newArrayList>() //noinspection unchecked,RedundantTypeArguments - TaskPrioritizer.splitLexicallyLocalDescriptors(members, c.scope.getContainingDeclaration(), locals, nonlocals); + splitLexicallyLocalDescriptors(members, c.scope.getContainingDeclaration(), locals, nonlocals) - localsList.add(locals); - nonlocalsList.add(nonlocals); + localsList.add(locals) + nonlocalsList.add(nonlocals) } //locals - c.result.addCandidates(localsList); + c.result.addCandidates(localsList) //try all implicit receivers as explicit - for (ReceiverValue implicitReceiver : implicitReceivers) { - addCandidatesForExplicitReceiver(implicitReceiver, implicitReceivers, c, /*isExplicit=*/false); + for (implicitReceiver in implicitReceivers) { + addCandidatesForExplicitReceiver(implicitReceiver, implicitReceivers, c, isExplicit = false) } //nonlocals - c.result.addCandidates(nonlocalsList); + c.result.addCandidates(nonlocalsList) //static (only for better error reporting) - for (ReceiverValue implicitReceiver : implicitReceivers) { - addMembers(implicitReceiver, c, /*static=*/true, /*isExplicit=*/false); + for (implicitReceiver in implicitReceivers) { + addMembers(implicitReceiver, c, staticMembers = true, isExplicit = false) } } - private static void addCandidatesForInvoke( - @NotNull ReceiverValue explicitReceiver, - @NotNull TaskPrioritizerContext c - ) { - List implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(c.scope); + private fun addCandidatesForInvoke(explicitReceiver: ReceiverValue, c: TaskPrioritizerContext) { + val implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(c.scope) // For 'a.foo()' where foo has function type, // a is explicitReceiver, foo is variableReceiver. - ReceiverValue variableReceiver = c.context.call.getDispatchReceiver(); - assert variableReceiver.exists() : "'Invoke' call hasn't got variable receiver"; + val variableReceiver = c.context.call.getDispatchReceiver() + assert(variableReceiver.exists(), "'Invoke' call hasn't got variable receiver") // For invocation a.foo() explicit receiver 'a' // can be a receiver for 'foo' variable @@ -325,7 +285,7 @@ public class TaskPrioritizer { // (1) a.foo + foo.invoke() if (!explicitReceiver.exists()) { - addCandidatesForExplicitReceiver(variableReceiver, implicitReceivers, c, /*isExplicit=*/true); + addCandidatesForExplicitReceiver(variableReceiver, implicitReceivers, c, isExplicit = true) } // (2) foo + a.invoke() @@ -336,176 +296,145 @@ public class TaskPrioritizer { if (explicitReceiver.exists()) { //a.foo() - addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, explicitReceiver, c, BOTH_RECEIVERS); - return; + addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, explicitReceiver, c, BOTH_RECEIVERS) + return } // with (a) { foo() } - for (ReceiverValue implicitReceiver : implicitReceivers) { - addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, implicitReceiver, c, DISPATCH_RECEIVER); + for (implicitReceiver in implicitReceivers) { + addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver, implicitReceiver, c, DISPATCH_RECEIVER) } } - private static void addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver( - @NotNull ReceiverValue dispatchReceiver, - @NotNull ReceiverValue receiverParameter, - @NotNull TaskPrioritizerContext c, - @NotNull ExplicitReceiverKind receiverKind + private fun addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver( + dispatchReceiver: ReceiverValue, + receiverParameter: ReceiverValue, + c: TaskPrioritizerContext, + receiverKind: ExplicitReceiverKind ) { - for (CallableDescriptorCollector callableDescriptorCollector : c.callableDescriptorCollectors) { - addMemberExtensionCandidates(dispatchReceiver, receiverParameter, callableDescriptorCollector, c, receiverKind); + for (callableDescriptorCollector in c.callableDescriptorCollectors) { + addMemberExtensionCandidates(dispatchReceiver, receiverParameter, callableDescriptorCollector, c, receiverKind) } } - private static Collection> convertWithReceivers( - @NotNull Collection descriptors, - @NotNull ReceiverValue dispatchReceiver, - @NotNull ReceiverValue extensionReceiver, - @NotNull ExplicitReceiverKind explicitReceiverKind, - @NotNull Call call - ) { - Collection> result = Lists.newArrayList(); - convertWithReceivers(descriptors, dispatchReceiver, extensionReceiver, result, explicitReceiverKind, call); - return result; + private fun convertWithReceivers( + descriptors: Collection, + dispatchReceiver: ReceiverValue, + extensionReceiver: ReceiverValue, + explicitReceiverKind: ExplicitReceiverKind, + call: Call + ): Collection> { + val result = Lists.newArrayList>() + convertWithReceivers(descriptors, dispatchReceiver, extensionReceiver, result, explicitReceiverKind, call) + return result } - private static void convertWithReceivers( - @NotNull Collection descriptors, - @NotNull ReceiverValue dispatchReceiver, - @NotNull ReceiverValue extensionReceiver, - @NotNull Collection> result, - @NotNull ExplicitReceiverKind explicitReceiverKind, - @NotNull Call call + private fun convertWithReceivers( + descriptors: Collection, + dispatchReceiver: ReceiverValue, + extensionReceiver: ReceiverValue, + result: MutableCollection>, + explicitReceiverKind: ExplicitReceiverKind, + call: Call ) { - for (D descriptor : descriptors) { - ResolutionCandidate candidate = ResolutionCandidate.create(call, descriptor); - candidate.setDispatchReceiver(dispatchReceiver); - candidate.setExtensionReceiver(extensionReceiver); - candidate.setExplicitReceiverKind(explicitReceiverKind); - result.add(candidate); + for (descriptor in descriptors) { + val candidate = ResolutionCandidate.create(call, descriptor) + candidate.setDispatchReceiver(dispatchReceiver) + candidate.setExtensionReceiver(extensionReceiver) + candidate.setExplicitReceiverKind(explicitReceiverKind) + result.add(candidate) } } - public static Collection> convertWithImpliedThisAndNoReceiver( - @NotNull JetScope scope, - @NotNull Collection descriptors, - @NotNull Call call - ) { - return convertWithImpliedThis(scope, NO_RECEIVER, descriptors, NO_EXPLICIT_RECEIVER, call); + public fun convertWithImpliedThisAndNoReceiver( + scope: JetScope, + descriptors: Collection, + call: Call + ): Collection> { + return convertWithImpliedThis(scope, NO_RECEIVER, descriptors, NO_EXPLICIT_RECEIVER, call) } - public static Collection> convertWithImpliedThis( - @NotNull JetScope scope, - @NotNull ReceiverValue receiverParameter, - @NotNull Collection descriptors, - @NotNull ExplicitReceiverKind receiverKind, - @NotNull Call call - ) { - Collection> result = Lists.newArrayList(); - for (D descriptor : descriptors) { - ResolutionCandidate candidate = ResolutionCandidate.create(call, descriptor); - candidate.setExtensionReceiver(receiverParameter); - candidate.setExplicitReceiverKind(receiverKind); + public fun convertWithImpliedThis( + scope: JetScope, + receiverParameter: ReceiverValue, + descriptors: Collection, + receiverKind: ExplicitReceiverKind, + call: Call + ): Collection> { + val result = Lists.newArrayList>() + for (descriptor in descriptors) { + val candidate = ResolutionCandidate.create(call, descriptor) + candidate.setExtensionReceiver(receiverParameter) + candidate.setExplicitReceiverKind(receiverKind) if (setImpliedThis(scope, candidate)) { - result.add(candidate); + result.add(candidate) } } - return result; + return result } - private static boolean setImpliedThis( - @NotNull JetScope scope, - @NotNull ResolutionCandidate candidate - ) { - ReceiverParameterDescriptor dispatchReceiver = candidate.getDescriptor().getDispatchReceiverParameter(); - if (dispatchReceiver == null) return true; - List receivers = scope.getImplicitReceiversHierarchy(); - for (ReceiverParameterDescriptor receiver : receivers) { + private fun setImpliedThis( + scope: JetScope, + candidate: ResolutionCandidate + ): Boolean { + val dispatchReceiver = candidate.getDescriptor().getDispatchReceiverParameter() + if (dispatchReceiver == null) return true + val receivers = scope.getImplicitReceiversHierarchy() + for (receiver in receivers) { if (JetTypeChecker.DEFAULT.isSubtypeOf(receiver.getType(), dispatchReceiver.getType())) { // TODO : Smartcasts & nullability - candidate.setDispatchReceiver(dispatchReceiver.getValue()); - return true; + candidate.setDispatchReceiver(dispatchReceiver.getValue()) + return true } } - return false; + return false } - public List> computePrioritizedTasksFromCandidates( - @NotNull BasicCallResolutionContext context, - @NotNull final Collection> candidates, - @NotNull TracingStrategy tracing + public fun computePrioritizedTasksFromCandidates( + context: BasicCallResolutionContext, + candidates: Collection>, + tracing: TracingStrategy + ): List> { + val result = ResolutionTaskHolder(storageManager, context, MyPriorityProvider(context), tracing) + result.addCandidates { + candidates + } + return result.getTasks() + } + + private class MyPriorityProvider(private val context: BasicCallResolutionContext) : + ResolutionTaskHolder.PriorityProvider> { + + override fun getPriority(candidate: ResolutionCandidate) + = (if (isVisible(candidate)) 2 else 0) + (if (isSynthesized(candidate)) 0 else 1) + + override fun getMaxPriority() = 3 + + private fun isVisible(call: ResolutionCandidate?): Boolean { + if (call == null) return false + val candidateDescriptor = call.getDescriptor() + if (ErrorUtils.isError(candidateDescriptor)) return true + return Visibilities.isVisible(candidateDescriptor, context.scope.getContainingDeclaration()) + } + + private fun isSynthesized(call: ResolutionCandidate): Boolean { + val descriptor = call.getDescriptor() + return descriptor is CallableMemberDescriptor && isOrOverridesSynthesized(descriptor : CallableMemberDescriptor) + } + } + + private class TaskPrioritizerContext( + val name: Name, + val result: ResolutionTaskHolder, + val context: BasicCallResolutionContext, + val scope: JetScope, + val callableDescriptorCollectors: CallableDescriptorCollectors ) { - ResolutionTaskHolder result = new ResolutionTaskHolder( - storageManager, context, new MyPriorityProvider(context), tracing); - result.addCandidates(new Function0>>() { - @Override - public Collection> invoke() { - return candidates; - } - }); - return result.getTasks(); - } - - private static class MyPriorityProvider - implements ResolutionTaskHolder.PriorityProvider> { - private final BasicCallResolutionContext context; - - public MyPriorityProvider(BasicCallResolutionContext context) { - this.context = context; + fun replaceScope(newScope: JetScope): TaskPrioritizerContext { + return TaskPrioritizerContext(name, result, context, newScope, callableDescriptorCollectors) } - @Override - public int getPriority(ResolutionCandidate call) { - return (isVisible(call) ? 2 : 0) + (isSynthesized(call) ? 0 : 1); + fun replaceCollectors(newCollectors: CallableDescriptorCollectors): TaskPrioritizerContext { + return TaskPrioritizerContext(name, result, context, scope, newCollectors) } - - @Override - public int getMaxPriority() { - return 3; - } - - private boolean isVisible(ResolutionCandidate call) { - if (call == null) return false; - D candidateDescriptor = call.getDescriptor(); - if (ErrorUtils.isError(candidateDescriptor)) return true; - return Visibilities.isVisible(candidateDescriptor, context.scope.getContainingDeclaration()); - } - - private boolean isSynthesized(ResolutionCandidate call) { - D descriptor = call.getDescriptor(); - return descriptor instanceof CallableMemberDescriptor && - isOrOverridesSynthesized((CallableMemberDescriptor) descriptor); - } - } - - private static class TaskPrioritizerContext { - @NotNull public final Name name; - @NotNull public final ResolutionTaskHolder result; - @NotNull public final BasicCallResolutionContext context; - @NotNull public final JetScope scope; - @NotNull public final CallableDescriptorCollectors callableDescriptorCollectors; - - private TaskPrioritizerContext( - @NotNull Name name, - @NotNull ResolutionTaskHolder result, - @NotNull BasicCallResolutionContext context, - @NotNull JetScope scope, - @NotNull CallableDescriptorCollectors callableDescriptorCollectors - ) { - this.name = name; - this.result = result; - this.context = context; - this.scope = scope; - this.callableDescriptorCollectors = callableDescriptorCollectors; - } - - private TaskPrioritizerContext replaceScope(JetScope newScope) { - return new TaskPrioritizerContext(name, result, context, newScope, callableDescriptorCollectors); - } - - private TaskPrioritizerContext replaceCollectors(CallableDescriptorCollectors newCollectors) { - return new TaskPrioritizerContext(name, result, context, scope, newCollectors); - } - - } }