From f06f557daeb44b56a826f8a5f2607bae4ac38255 Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Thu, 19 Nov 2015 19:51:23 +0300 Subject: [PATCH] Minor. introduce CallResolver.TaskContextForMigration --- .../kotlin/resolve/calls/CallResolver.java | 132 ++++++++++++++---- 1 file changed, 103 insertions(+), 29 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java index e86f1eb11c3..4c661f53bad 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -26,7 +26,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.Annotations; -import org.jetbrains.kotlin.lexer.KtTokens; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus; import org.jetbrains.kotlin.psi.*; @@ -60,10 +59,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions; import org.jetbrains.kotlin.util.PerformanceCounter; import javax.inject.Inject; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; +import java.util.*; import static org.jetbrains.kotlin.diagnostics.Errors.*; import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS; @@ -144,7 +140,7 @@ public class CallResolver { CallableDescriptorCollectors callableDescriptorCollectors = CallableDescriptorCollectors.VARIABLES; return computeTasksAndResolveCall( context, referencedName, nameExpression, - callableDescriptorCollectors, CallTransformer.VARIABLE_CALL_TRANSFORMER); + callableDescriptorCollectors, CallTransformer.VARIABLE_CALL_TRANSFORMER, ResolveKind.VARIABLE); } @NotNull @@ -154,7 +150,7 @@ public class CallResolver { ) { return computeTasksAndResolveCall( context, nameExpression.getReferencedNameAsName(), nameExpression, - CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.MEMBER_CALL_TRANSFORMER); + CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.MEMBER_CALL_TRANSFORMER, ResolveKind.CALLABLE_REFERENCE); } @NotNull @@ -167,7 +163,7 @@ public class CallResolver { BasicCallResolutionContext callResolutionContext = BasicCallResolutionContext.create(context, call, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS); return computeTasksAndResolveCall( callResolutionContext, name, functionReference, - CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER); + CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER, ResolveKind.FUNCTION); } @NotNull @@ -177,7 +173,8 @@ public class CallResolver { ) { return computeTasksAndResolveCall( context, OperatorNameConventions.INVOKE, tracing, - CallableDescriptorCollectors.FUNCTIONS, CallTransformer.FUNCTION_CALL_TRANSFORMER); + CallableDescriptorCollectors.FUNCTIONS, CallTransformer.FUNCTION_CALL_TRANSFORMER, + ResolveKind.INVOKE); } @NotNull @@ -186,10 +183,11 @@ public class CallResolver { @NotNull Name name, @NotNull KtReferenceExpression referenceExpression, @NotNull CallableDescriptorCollectors collectors, - @NotNull CallTransformer callTransformer + @NotNull CallTransformer callTransformer, + @NotNull ResolveKind kind ) { TracingStrategy tracing = TracingStrategyImpl.create(referenceExpression, context.call); - return computeTasksAndResolveCall(context, name, tracing, collectors, callTransformer); + return computeTasksAndResolveCall(context, name, tracing, collectors, callTransformer, kind); } @NotNull @@ -198,13 +196,21 @@ public class CallResolver { @NotNull final Name name, @NotNull final TracingStrategy tracing, @NotNull final CallableDescriptorCollectors collectors, - @NotNull final CallTransformer callTransformer + @NotNull final CallTransformer callTransformer, + @NotNull final ResolveKind kind ) { return callResolvePerfCounter.time(new Function0>() { @Override public OverloadResolutionResults invoke() { - List> tasks = taskPrioritizer.computePrioritizedTasks(context, name, tracing, collectors); - return doResolveCallOrGetCachedResults(context, tasks, callTransformer, tracing); + TaskContextForMigration contextForMigration = new TaskContextForMigration( + kind, callTransformer, name, null, + new Function0>>() { + @Override + public List> invoke() { + return taskPrioritizer.computePrioritizedTasks(context, name, tracing, collectors); + } + }); + return doResolveCallOrGetCachedResults(context, contextForMigration, tracing); } }); } @@ -230,9 +236,16 @@ public class CallResolver { return callResolvePerfCounter.time(new Function0>() { @Override public OverloadResolutionResults invoke() { - List> prioritizedTasks = - taskPrioritizer.computePrioritizedTasksFromCandidates(context, candidates, tracing); - return doResolveCallOrGetCachedResults(context, prioritizedTasks, callTransformer, tracing); + TaskContextForMigration contextForMigration = new TaskContextForMigration( + ResolveKind.GIVEN_CANDIDATES, callTransformer, null, candidates, + new Function0>>() { + @Override + public List> invoke() { + return taskPrioritizer.computePrioritizedTasksFromCandidates( + context, candidates, tracing); + } + }); + return doResolveCallOrGetCachedResults(context, contextForMigration, tracing); } }); } @@ -279,7 +292,9 @@ public class CallResolver { KtArrayAccessExpression arrayAccessExpression = (KtArrayAccessExpression) context.call.getCallElement(); return computeTasksAndResolveCall( context, name, arrayAccessExpression, - CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER); + CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, + CallTransformer.FUNCTION_CALL_TRANSFORMER, + ResolveKind.FUNCTION); } KtExpression calleeExpression = context.call.getCalleeExpression(); @@ -287,7 +302,7 @@ public class CallResolver { KtSimpleNameExpression expression = (KtSimpleNameExpression) calleeExpression; return computeTasksAndResolveCall( context, expression.getReferencedNameAsName(), expression, - CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER); + CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER, ResolveKind.FUNCTION); } else if (calleeExpression instanceof KtConstructorCalleeExpression) { return resolveCallForConstructor(context, (KtConstructorCalleeExpression) calleeExpression); @@ -458,21 +473,33 @@ public class CallResolver { return callResolvePerfCounter.time(new Function0>() { @Override public OverloadResolutionResults invoke() { - BasicCallResolutionContext basicCallResolutionContext = + final BasicCallResolutionContext basicCallResolutionContext = BasicCallResolutionContext.create(context, call, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS, dataFlowInfoForArguments); - List> tasks = - taskPrioritizer.computePrioritizedTasksFromCandidates( - basicCallResolutionContext, Collections.singleton(candidate), tracing); - return doResolveCallOrGetCachedResults(basicCallResolutionContext, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing); + final Set> candidates = Collections.singleton(candidate); + + TaskContextForMigration contextForMigration = + new TaskContextForMigration( + ResolveKind.GIVEN_CANDIDATES, CallTransformer.FUNCTION_CALL_TRANSFORMER, null, candidates, + new Function0>>() { + @Override + public List> invoke() { + + return taskPrioritizer.computePrioritizedTasksFromCandidates( + basicCallResolutionContext, candidates, tracing); + } + } + ); + + + return doResolveCallOrGetCachedResults(basicCallResolutionContext, contextForMigration, tracing); } }); } private OverloadResolutionResultsImpl doResolveCallOrGetCachedResults( @NotNull BasicCallResolutionContext context, - @NotNull List> prioritizedTasks, - @NotNull CallTransformer callTransformer, + @NotNull TaskContextForMigration contextForMigration, @NotNull TracingStrategy tracing ) { Call call = context.call; @@ -484,7 +511,7 @@ public class CallResolver { BindingContextUtilsKt.recordScope(newContext.trace, newContext.scope, newContext.call.getCalleeExpression()); BindingContextUtilsKt.recordDataFlowInfo(newContext, newContext.call.getCalleeExpression()); - OverloadResolutionResultsImpl results = doResolveCall(newContext, prioritizedTasks, callTransformer, tracing); + OverloadResolutionResultsImpl results = doResolveCall(newContext, contextForMigration, tracing); DelegatingBindingTrace deltasTraceForTypeInference = ((OverloadResolutionResultsImpl) results).getTrace(); if (deltasTraceForTypeInference != null) { deltasTraceForTypeInference.addOwnDataTo(traceToResolveCall); @@ -544,8 +571,7 @@ public class CallResolver { @NotNull private OverloadResolutionResultsImpl doResolveCall( @NotNull BasicCallResolutionContext context, - @NotNull List> prioritizedTasks, // high to low priority - @NotNull CallTransformer callTransformer, + @NotNull TaskContextForMigration contextForMigration, @NotNull TracingStrategy tracing ) { if (context.checkArguments == CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS) { @@ -566,6 +592,16 @@ public class CallResolver { } } + return doResolveCall(context, contextForMigration.lazyTasks.invoke(), contextForMigration.callTransformer, tracing); + } + + @NotNull + private OverloadResolutionResultsImpl doResolveCall( + @NotNull BasicCallResolutionContext context, + @NotNull List> prioritizedTasks, // high to low priority + @NotNull CallTransformer callTransformer, + @NotNull TracingStrategy tracing + ) { Collection> allCandidates = Lists.newArrayList(); OverloadResolutionResultsImpl successfulResults = null; TemporaryBindingTrace traceForFirstNonemptyCandidateSet = null; @@ -693,4 +729,42 @@ public class CallResolver { task.addResolvedCall(resolvedCall); } } + + private static class TaskContextForMigration { + @NotNull + final Function0>> lazyTasks; + + @NotNull + final CallTransformer callTransformer; + + @Nullable + final Name name; + + @Nullable + final Collection> givenCandidates; + + @NotNull + final ResolveKind resolveKind; + + private TaskContextForMigration( + @NotNull ResolveKind kind, + @NotNull CallTransformer transformer, + @Nullable Name name, + @Nullable Collection> candidates, @NotNull Function0>> tasks + ) { + lazyTasks = tasks; + callTransformer = transformer; + this.name = name; + givenCandidates = candidates; + resolveKind = kind; + } + } + + public enum ResolveKind { + FUNCTION, + INVOKE, + VARIABLE, + CALLABLE_REFERENCE, + GIVEN_CANDIDATES, + } }