From 63b3cbafa43223bfca45d9761aa1fc7640aadd39 Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Wed, 17 Feb 2016 16:08:53 +0300 Subject: [PATCH] Remove old resolution algorithm. --- .../kotlin/resolve/calls/CallResolver.java | 248 +------- .../kotlin/resolve/calls/CallTransformer.java | 176 +----- .../tasks/CallableDescriptorCollectors.kt | 259 --------- .../resolve/calls/tasks/ResolutionTask.java | 124 ---- .../calls/tasks/ResolutionTaskHolder.kt | 66 --- .../resolve/calls/tasks/TaskPrioritizer.kt | 538 ------------------ .../resolve/calls/tasks/dynamicCalls.kt | 17 +- .../kotlin/checkers/LazyOperationsLog.kt | 6 +- 8 files changed, 29 insertions(+), 1405 deletions(-) delete mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt delete mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java delete mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt delete mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt 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 5478c91b006..c96242bb331 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -16,12 +16,8 @@ package org.jetbrains.kotlin.resolve.calls; -import com.google.common.collect.Lists; -import com.intellij.openapi.util.Condition; import com.intellij.psi.PsiElement; -import com.intellij.util.containers.ContainerUtil; import kotlin.Pair; -import kotlin.Unit; import kotlin.jvm.functions.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -39,14 +35,10 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt; import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker; import org.jetbrains.kotlin.resolve.calls.context.*; import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments; -import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall; -import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults; import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl; -import org.jetbrains.kotlin.resolve.calls.results.ResolutionResultsHandler; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.calls.tasks.*; -import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollectors; import org.jetbrains.kotlin.resolve.calls.tower.NewResolveOldInference; import org.jetbrains.kotlin.resolve.calls.util.CallMaker; import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt; @@ -66,10 +58,6 @@ import java.util.*; import static org.jetbrains.kotlin.diagnostics.Errors.*; import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.RESOLVE_FUNCTION_ARGUMENTS; -import static org.jetbrains.kotlin.resolve.calls.callResolverUtil.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS; -import static org.jetbrains.kotlin.resolve.calls.context.CandidateResolveMode.EXIT_ON_FIRST_ERROR; -import static org.jetbrains.kotlin.resolve.calls.context.CandidateResolveMode.FULLY; -import static org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults.Code.CANDIDATES_WITH_WRONG_RECEIVER; import static org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults.Code.INCOMPLETE_TYPE_INFERENCE; import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; @@ -77,27 +65,19 @@ import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; public class CallResolver { private ExpressionTypingServices expressionTypingServices; private TypeResolver typeResolver; - private CandidateResolver candidateResolver; private ArgumentTypeResolver argumentTypeResolver; private GenericCandidateResolver genericCandidateResolver; private CallCompleter callCompleter; private NewResolveOldInference newCallResolver; - private final TaskPrioritizer taskPrioritizer; - private final ResolutionResultsHandler resolutionResultsHandler; - @NotNull private KotlinBuiltIns builtIns; + private final KotlinBuiltIns builtIns; private static final PerformanceCounter callResolvePerfCounter = PerformanceCounter.Companion.create("Call resolve", ExpressionTypingVisitorDispatcher.typeInfoPerfCounter); - private static final PerformanceCounter candidatePerfCounter = PerformanceCounter.Companion.create("Call resolve candidate analysis", true); public static boolean useNewResolve = !"false".equals(System.getProperty("kotlin.internal.new_resolve")); public CallResolver( - @NotNull TaskPrioritizer taskPrioritizer, - @NotNull ResolutionResultsHandler resolutionResultsHandler, @NotNull KotlinBuiltIns builtIns ) { - this.taskPrioritizer = taskPrioritizer; - this.resolutionResultsHandler = resolutionResultsHandler; this.builtIns = builtIns; } @@ -113,12 +93,6 @@ public class CallResolver { this.typeResolver = typeResolver; } - // component dependency cycle - @Inject - public void setCandidateResolver(@NotNull CandidateResolver candidateResolver) { - this.candidateResolver = candidateResolver; - } - // component dependency cycle @Inject public void setArgumentTypeResolver(@NotNull ArgumentTypeResolver argumentTypeResolver) { @@ -149,10 +123,9 @@ public class CallResolver { assert calleeExpression instanceof KtSimpleNameExpression; KtSimpleNameExpression nameExpression = (KtSimpleNameExpression) calleeExpression; Name referencedName = nameExpression.getReferencedNameAsName(); - CallableDescriptorCollectors callableDescriptorCollectors = CallableDescriptorCollectors.VARIABLES; return computeTasksAndResolveCall( context, referencedName, nameExpression, - callableDescriptorCollectors, CallTransformer.VARIABLE_CALL_TRANSFORMER, ResolveKind.VARIABLE); + ResolveKind.VARIABLE); } @NotNull @@ -162,7 +135,7 @@ public class CallResolver { ) { return computeTasksAndResolveCall( context, nameExpression.getReferencedNameAsName(), nameExpression, - CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.MEMBER_CALL_TRANSFORMER, ResolveKind.CALLABLE_REFERENCE); + ResolveKind.CALLABLE_REFERENCE); } @NotNull @@ -175,7 +148,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, ResolveKind.FUNCTION); + ResolveKind.FUNCTION); } @NotNull @@ -185,7 +158,6 @@ public class CallResolver { ) { return computeTasksAndResolveCall( context, OperatorNameConventions.INVOKE, tracing, - CallableDescriptorCollectors.FUNCTIONS, CallTransformer.FUNCTION_CALL_TRANSFORMER, ResolveKind.INVOKE); } @@ -194,12 +166,10 @@ public class CallResolver { @NotNull BasicCallResolutionContext context, @NotNull Name name, @NotNull KtReferenceExpression referenceExpression, - @NotNull CallableDescriptorCollectors collectors, - @NotNull CallTransformer callTransformer, @NotNull ResolveKind kind ) { TracingStrategy tracing = TracingStrategyImpl.create(referenceExpression, context.call); - return computeTasksAndResolveCall(context, name, tracing, collectors, callTransformer, kind); + return computeTasksAndResolveCall(context, name, tracing, kind); } @NotNull @@ -207,21 +177,14 @@ public class CallResolver { @NotNull final BasicCallResolutionContext context, @NotNull final Name name, @NotNull final TracingStrategy tracing, - @NotNull final CallableDescriptorCollectors collectors, - @NotNull final CallTransformer callTransformer, @NotNull final ResolveKind kind ) { return callResolvePerfCounter.time(new Function0>() { @Override public OverloadResolutionResults invoke() { - TaskContextForMigration contextForMigration = new TaskContextForMigration( - kind, callTransformer, name, null, - new Function0>>() { - @Override - public List> invoke() { - return taskPrioritizer.computePrioritizedTasks(context, name, tracing, collectors); - } - }); + TaskContextForMigration contextForMigration = new TaskContextForMigration( + kind, name, null + ); return doResolveCallOrGetCachedResults(context, contextForMigration, tracing); } }); @@ -231,10 +194,9 @@ public class CallResolver { private OverloadResolutionResults computeTasksFromCandidatesAndResolvedCall( @NotNull BasicCallResolutionContext context, @NotNull KtReferenceExpression referenceExpression, - @NotNull Collection> candidates, - @NotNull CallTransformer callTransformer + @NotNull Collection> candidates ) { - return computeTasksFromCandidatesAndResolvedCall(context, candidates, callTransformer, + return computeTasksFromCandidatesAndResolvedCall(context, candidates, TracingStrategyImpl.create(referenceExpression, context.call)); } @@ -242,21 +204,14 @@ public class CallResolver { private OverloadResolutionResults computeTasksFromCandidatesAndResolvedCall( @NotNull final BasicCallResolutionContext context, @NotNull final Collection> candidates, - @NotNull final CallTransformer callTransformer, @NotNull final TracingStrategy tracing ) { return callResolvePerfCounter.time(new Function0>() { @Override public OverloadResolutionResults invoke() { - TaskContextForMigration contextForMigration = new TaskContextForMigration( - ResolveKind.GIVEN_CANDIDATES, callTransformer, null, candidates, - new Function0>>() { - @Override - public List> invoke() { - return taskPrioritizer.computePrioritizedTasksFromCandidates( - context, candidates, tracing); - } - }); + TaskContextForMigration contextForMigration = new TaskContextForMigration( + ResolveKind.GIVEN_CANDIDATES, null, candidates + ); return doResolveCallOrGetCachedResults(context, contextForMigration, tracing); } }); @@ -304,8 +259,6 @@ public class CallResolver { KtArrayAccessExpression arrayAccessExpression = (KtArrayAccessExpression) context.call.getCallElement(); return computeTasksAndResolveCall( context, name, arrayAccessExpression, - CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, - CallTransformer.FUNCTION_CALL_TRANSFORMER, ResolveKind.FUNCTION); } @@ -314,7 +267,7 @@ public class CallResolver { KtSimpleNameExpression expression = (KtSimpleNameExpression) calleeExpression; return computeTasksAndResolveCall( context, expression.getReferencedNameAsName(), expression, - CallableDescriptorCollectors.FUNCTIONS_AND_VARIABLES, CallTransformer.FUNCTION_CALL_TRANSFORMER, ResolveKind.FUNCTION); + ResolveKind.FUNCTION); } else if (calleeExpression instanceof KtConstructorCalleeExpression) { return resolveCallForConstructor(context, (KtConstructorCalleeExpression) calleeExpression); @@ -388,7 +341,7 @@ public class CallResolver { Collection> candidates = candidatesAndContext.getFirst(); context = candidatesAndContext.getSecond(); - return computeTasksFromCandidatesAndResolvedCall(context, functionReference, candidates, CallTransformer.FUNCTION_CALL_TRANSFORMER); + return computeTasksFromCandidatesAndResolvedCall(context, functionReference, candidates); } @Nullable @@ -479,7 +432,7 @@ public class CallResolver { return checkArgumentTypesAndFail(context); } - return computeTasksFromCandidatesAndResolvedCall(context, candidates, CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing); + return computeTasksFromCandidatesAndResolvedCall(context, candidates, tracing); } @NotNull @@ -529,22 +482,14 @@ public class CallResolver { return callResolvePerfCounter.time(new Function0>() { @Override public OverloadResolutionResults invoke() { - final BasicCallResolutionContext basicCallResolutionContext = + BasicCallResolutionContext basicCallResolutionContext = BasicCallResolutionContext.create(context, call, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS, dataFlowInfoForArguments); - final Set> candidates = Collections.singleton(candidate); + 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); - } - } + TaskContextForMigration contextForMigration = + new TaskContextForMigration( + ResolveKind.GIVEN_CANDIDATES, null, candidates ); @@ -555,7 +500,7 @@ public class CallResolver { private OverloadResolutionResultsImpl doResolveCallOrGetCachedResults( @NotNull BasicCallResolutionContext context, - @NotNull TaskContextForMigration contextForMigration, + @NotNull TaskContextForMigration contextForMigration, @NotNull TracingStrategy tracing ) { Call call = context.call; @@ -627,7 +572,7 @@ public class CallResolver { @NotNull private OverloadResolutionResultsImpl doResolveCall( @NotNull BasicCallResolutionContext context, - @NotNull TaskContextForMigration contextForMigration, + @NotNull TaskContextForMigration contextForMigration, @NotNull TracingStrategy tracing ) { if (context.checkArguments == CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS) { @@ -656,151 +601,11 @@ public class CallResolver { else { return (OverloadResolutionResultsImpl) newCallResolver.runResolveForGivenCandidates(context, tracing, contextForMigration.givenCandidates); } - - //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; - OverloadResolutionResultsImpl resultsForFirstNonemptyCandidateSet = null; - for (ResolutionTask task : prioritizedTasks) { - if (task.getCandidates().isEmpty()) continue; - - TemporaryBindingTrace taskTrace = - TemporaryBindingTrace.create(context.trace, "trace to resolve a task for", task.call.getCalleeExpression()); - OverloadResolutionResultsImpl results = performResolution(task.replaceBindingTrace(taskTrace), callTransformer); - - - allCandidates.addAll(task.getResolvedCalls()); - - if (successfulResults != null) continue; - - if (results.isSuccess() || results.isAmbiguity()) { - taskTrace.commit(); - successfulResults = results; - } - if (results.getResultCode() == INCOMPLETE_TYPE_INFERENCE) { - results.setTrace(taskTrace); - successfulResults = results; - } - boolean updateResults = traceForFirstNonemptyCandidateSet == null - || (resultsForFirstNonemptyCandidateSet.getResultCode() == CANDIDATES_WITH_WRONG_RECEIVER - && results.getResultCode() != CANDIDATES_WITH_WRONG_RECEIVER); - if (!task.getCandidates().isEmpty() && !results.isNothing() && updateResults) { - traceForFirstNonemptyCandidateSet = taskTrace; - resultsForFirstNonemptyCandidateSet = results; - } - - if (successfulResults != null && !context.collectAllCandidates) break; - } - OverloadResolutionResultsImpl results; - if (successfulResults != null) { - results = successfulResults; - } - else if (traceForFirstNonemptyCandidateSet == null) { - tracing.unresolvedReference(context.trace); - argumentTypeResolver.checkTypesWithNoCallee(context, SHAPE_FUNCTION_ARGUMENTS); - results = OverloadResolutionResultsImpl.nameNotFound(); - } - else { - traceForFirstNonemptyCandidateSet.commit(); - results = resultsForFirstNonemptyCandidateSet; - } - results.setAllCandidates(context.collectAllCandidates ? allCandidates : null); - return results; } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - @NotNull - private OverloadResolutionResultsImpl performResolution( - @NotNull ResolutionTask task, - @NotNull CallTransformer callTransformer - ) { - CandidateResolveMode mode = task.collectAllCandidates ? FULLY : EXIT_ON_FIRST_ERROR; - List> contexts = collectCallCandidateContext(task, callTransformer, mode); - boolean isSuccess = ContainerUtil.exists(contexts, new Condition>() { - @Override - public boolean value(CallCandidateResolutionContext context) { - return context.candidateCall.getStatus().possibleTransformToSuccess(); - } - }); - if (!isSuccess && mode == EXIT_ON_FIRST_ERROR) { - contexts = collectCallCandidateContext(task, callTransformer, FULLY); - } - - for (CallCandidateResolutionContext context : contexts) { - addResolvedCall(task, callTransformer, context); - } - - OverloadResolutionResultsImpl results = resolutionResultsHandler.computeResultAndReportErrors( - task, task.tracing, task.getResolvedCalls()); - if (!results.isSingleResult() && !results.isIncomplete()) { - argumentTypeResolver.checkTypesWithNoCallee(task.toBasic()); - } - return results; - } - - @NotNull - private List> collectCallCandidateContext( - @NotNull final ResolutionTask task, - @NotNull final CallTransformer callTransformer, - @NotNull final CandidateResolveMode candidateResolveMode - ) { - final List> candidateResolutionContexts = ContainerUtil.newArrayList(); - for (final ResolutionCandidate resolutionCandidate : task.getCandidates()) { - if (DeprecationUtilKt.isHiddenInResolution(resolutionCandidate.getDescriptor())) continue; - - candidatePerfCounter.time(new Function0() { - @Override - public Unit invoke() { - TemporaryBindingTrace candidateTrace = TemporaryBindingTrace.create( - task.trace, "trace to resolve candidate"); - Collection> contexts = - callTransformer.createCallContexts(resolutionCandidate, task, candidateTrace, candidateResolveMode); - for (CallCandidateResolutionContext context : contexts) { - candidateResolver.performResolutionForCandidateCall(context, task.checkArguments); - candidateResolutionContexts.add(context); - } - return Unit.INSTANCE; - } - }); - } - return candidateResolutionContexts; - } - - private void addResolvedCall( - @NotNull ResolutionTask task, - @NotNull CallTransformer callTransformer, - @NotNull CallCandidateResolutionContext context) { - /* important for 'variable as function case': temporary bind reference to descriptor (will be rewritten) - to have a binding to variable while 'invoke' call resolve */ - task.tracing.bindReference(context.candidateCall.getTrace(), context.candidateCall); - - Collection> resolvedCalls = callTransformer.transformCall(context, this, task); - - for (MutableResolvedCall resolvedCall : resolvedCalls) { - BindingTrace trace = resolvedCall.getTrace(); - task.tracing.bindReference(trace, resolvedCall); - task.tracing.bindResolvedCall(trace, resolvedCall); - task.addResolvedCall(resolvedCall); - } - } - - private static class TaskContextForMigration { - @NotNull - final Function0>> lazyTasks; - - @NotNull - final CallTransformer callTransformer; + private static class TaskContextForMigration { @Nullable final Name name; @@ -813,12 +618,9 @@ public class CallResolver { private TaskContextForMigration( @NotNull ResolveKind kind, - @NotNull CallTransformer transformer, @Nullable Name name, - @Nullable Collection> candidates, @NotNull Function0>> tasks + @Nullable Collection> candidates ) { - lazyTasks = tasks; - callTransformer = transformer; this.name = name; givenCandidates = candidates; resolveKind = kind; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java index 55ae7dc2e2b..a83b577b331 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallTransformer.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. + * Copyright 2010-2016 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. @@ -16,88 +16,22 @@ package org.jetbrains.kotlin.resolve.calls; -import com.google.common.base.Function; -import com.google.common.collect.Collections2; -import com.google.common.collect.Lists; import com.intellij.lang.ASTNode; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.descriptors.CallableDescriptor; -import org.jetbrains.kotlin.descriptors.FunctionDescriptor; -import org.jetbrains.kotlin.descriptors.VariableDescriptor; import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.ChainedTemporaryBindingTrace; -import org.jetbrains.kotlin.resolve.DelegatingBindingTrace; -import org.jetbrains.kotlin.resolve.TemporaryBindingTrace; -import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext; -import org.jetbrains.kotlin.resolve.calls.context.CallCandidateResolutionContext; -import org.jetbrains.kotlin.resolve.calls.context.CandidateResolveMode; -import org.jetbrains.kotlin.resolve.calls.context.ContextDependency; -import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall; -import org.jetbrains.kotlin.resolve.calls.model.ResolvedCallImpl; -import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCallImpl; -import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults; -import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsImpl; -import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind; -import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate; -import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionTask; -import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategyForInvoke; import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall; import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.kotlin.resolve.scopes.receivers.Receiver; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; -import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.util.OperatorNameConventions; -import java.util.Collection; import java.util.Collections; import java.util.List; -/** - * CallTransformer treats specially 'variable as function' call case, other cases keeps unchanged (base realization). - * - * For the call 'b.foo(1)' where foo is a variable that has method 'invoke' (for example of function type) - * CallTransformer creates two contexts, two calls in each, and performs second ('invoke') call resolution: - * - * context#1. calls: 'b.foo' 'invoke(1)' - * context#2. calls: 'foo' 'b.invoke(1)' - * - * If success VariableAsFunctionResolvedCall is created. - */ -public class CallTransformer { +public class CallTransformer { private CallTransformer() {} - /** - * Returns two contexts for 'variable as function' case (in FUNCTION_CALL_TRANSFORMER), one context otherwise - */ - @NotNull - public Collection> createCallContexts(@NotNull ResolutionCandidate candidate, - @NotNull ResolutionTask task, - @NotNull TemporaryBindingTrace candidateTrace, - @NotNull CandidateResolveMode candidateResolveMode - ) { - ResolvedCallImpl candidateCall = ResolvedCallImpl.create(candidate, candidateTrace, task.tracing, task.dataFlowInfoForArguments); - return Collections.singleton(CallCandidateResolutionContext.create(candidateCall, task, candidateTrace, task.tracing, task.call, - null, candidateResolveMode)); - } - - /** - * Returns collection of resolved calls for 'invoke' for 'variable as function' case (in FUNCTION_CALL_TRANSFORMER), - * the resolved call from callCandidateResolutionContext otherwise - */ - @NotNull - public Collection> transformCall(@NotNull CallCandidateResolutionContext callCandidateResolutionContext, - @NotNull CallResolver callResolver, - @NotNull ResolutionTask task - ) { - return Collections.singleton((MutableResolvedCall) callCandidateResolutionContext.candidateCall); - } - - - public static CallTransformer MEMBER_CALL_TRANSFORMER = new CallTransformer(); - - public static CallTransformer VARIABLE_CALL_TRANSFORMER = new CallTransformer(); - public static Call stripCallArguments(@NotNull Call call) { return new DelegatingCall(call) { @Override @@ -155,112 +89,6 @@ public class CallTransformer { }; } - public static CallTransformer FUNCTION_CALL_TRANSFORMER = new CallTransformer() { - @NotNull - @Override - public Collection> createCallContexts(@NotNull ResolutionCandidate candidate, - @NotNull ResolutionTask task, @NotNull TemporaryBindingTrace candidateTrace, - @NotNull CandidateResolveMode candidateResolveMode - ) { - - if (candidate.getDescriptor() instanceof FunctionDescriptor) { - return super.createCallContexts(candidate, task, candidateTrace, candidateResolveMode); - } - - assert candidate.getDescriptor() instanceof VariableDescriptor; - - boolean hasReceiver = candidate.getReceiverArgument() != null; - Call variableCall = stripCallArguments(task.call); - ResolutionCandidate variableCandidate = ResolutionCandidate.create( - variableCall, - candidate.getDescriptor(), - candidate.getDispatchReceiver(), - candidate.getReceiverArgument(), - candidate.getExplicitReceiverKind(), - null); - if (!hasReceiver) { - CallCandidateResolutionContext context = CallCandidateResolutionContext.create( - ResolvedCallImpl.create(variableCandidate, candidateTrace, task.tracing, task.dataFlowInfoForArguments), - task, candidateTrace, task.tracing, variableCall, null, candidateResolveMode); - return Collections.singleton(context); - } - CallCandidateResolutionContext contextWithReceiver = createContextWithChainedTrace( - variableCandidate, variableCall, candidateTrace, task, null, candidateResolveMode); - - Call variableCallWithoutReceiver = stripReceiver(variableCall); - ResolutionCandidate candidateWithoutReceiver = ResolutionCandidate.create( - variableCallWithoutReceiver, - candidate.getDescriptor(), - candidate.getDispatchReceiver(), - null, - ExplicitReceiverKind.NO_EXPLICIT_RECEIVER, null); - - CallCandidateResolutionContext contextWithoutReceiver = createContextWithChainedTrace( - candidateWithoutReceiver, variableCallWithoutReceiver, candidateTrace, task, variableCall.getExplicitReceiver(), - candidateResolveMode); - - return Lists.newArrayList(contextWithReceiver, contextWithoutReceiver); - } - - private CallCandidateResolutionContext createContextWithChainedTrace( - @NotNull ResolutionCandidate candidate, @NotNull Call call, @NotNull TemporaryBindingTrace temporaryTrace, - @NotNull ResolutionTask task, @Nullable Receiver receiverValue, - @NotNull CandidateResolveMode candidateResolveMode - ) { - ChainedTemporaryBindingTrace chainedTrace = ChainedTemporaryBindingTrace.create(temporaryTrace, "chained trace to resolve candidate", candidate); - ResolvedCallImpl resolvedCall = ResolvedCallImpl.create(candidate, chainedTrace, task.tracing, task.dataFlowInfoForArguments); - return CallCandidateResolutionContext.create(resolvedCall, task, chainedTrace, task.tracing, call, receiverValue, - candidateResolveMode); - } - - @NotNull - @Override - public Collection> transformCall( - @NotNull CallCandidateResolutionContext context, - @NotNull CallResolver callResolver, - @NotNull ResolutionTask task - ) { - CallableDescriptor descriptor = context.candidateCall.getCandidateDescriptor(); - if (descriptor instanceof FunctionDescriptor) { - return super.transformCall(context, callResolver, task); - } - - assert descriptor instanceof VariableDescriptor; - KotlinType returnType = descriptor.getReturnType(); - if (returnType == null) { - return Collections.emptyList(); - } - - final MutableResolvedCall variableResolvedCall = (MutableResolvedCall)context.candidateCall; - - KtExpression calleeExpression = task.call.getCalleeExpression(); - if (calleeExpression == null) return Collections.emptyList(); - - ExpressionReceiver variableReceiver = ExpressionReceiver.Companion.create( - calleeExpression, variableResolvedCall.getResultingDescriptor().getType(), context.trace.getBindingContext()); - Call functionCall = new CallForImplicitInvoke(context.explicitExtensionReceiverForInvoke, variableReceiver, task.call); - - DelegatingBindingTrace variableCallTrace = context.candidateCall.getTrace(); - BasicCallResolutionContext basicCallResolutionContext = BasicCallResolutionContext.create( - context.replaceBindingTrace(variableCallTrace).replaceContextDependency(ContextDependency.DEPENDENT), - functionCall, context.checkArguments, context.dataFlowInfoForArguments); - - // 'invoke' call resolve - TracingStrategyForInvoke tracingForInvoke = new TracingStrategyForInvoke( - calleeExpression, functionCall, variableReceiver.getType()); - OverloadResolutionResults results = callResolver.resolveCallForInvoke( - basicCallResolutionContext, tracingForInvoke); - Collection> calls = ((OverloadResolutionResultsImpl)results).getResultingCalls(); - - return Collections2.transform(calls, new Function, MutableResolvedCall>() { - @Override - public MutableResolvedCall apply(MutableResolvedCall functionResolvedCall) { - return new VariableAsFunctionResolvedCallImpl(functionResolvedCall, variableResolvedCall); - } - }); - } - }; - public static class CallForImplicitInvoke extends DelegatingCall { private final Call outerCall; private final Receiver explicitExtensionReceiver; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt deleted file mode 100644 index 090f226361f..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt +++ /dev/null @@ -1,259 +0,0 @@ -/* - * Copyright 2010-2015 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. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.resolve.calls.tasks.collectors - -import com.intellij.util.SmartList -import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.builtins.functions.FunctionInvokeDescriptor -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.incremental.components.LookupLocation -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.DescriptorUtils.isStaticNestedClass -import org.jetbrains.kotlin.resolve.LibrarySourceHacks -import org.jetbrains.kotlin.resolve.calls.tasks.createSynthesizedInvokes -import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject -import org.jetbrains.kotlin.resolve.descriptorUtil.hasClassValueDescriptor -import org.jetbrains.kotlin.resolve.scopes.* -import org.jetbrains.kotlin.resolve.scopes.utils.* -import org.jetbrains.kotlin.types.ErrorUtils -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.util.OperatorNameConventions -import org.jetbrains.kotlin.utils.addIfNotNull - -interface CallableDescriptorCollector { - - fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection - - fun getNonExtensionsByName(scope: HierarchicalScope, name: Name, location: LookupLocation): Collection - - // todo this is hack for static members priority - fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection - - fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection - - fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection - - fun getExtensionsByName(scope: HierarchicalScope, syntheticScopes: SyntheticScopes, name: Name, receiverTypes: Collection, location: LookupLocation): Collection -} - -private fun CallableDescriptorCollector.withDefaultFilter() = filtered { !LibrarySourceHacks.shouldSkip(it) } - -private val FUNCTIONS_COLLECTOR = FunctionCollector.withDefaultFilter() -private val VARIABLES_COLLECTOR = VariableCollector.withDefaultFilter() - -class CallableDescriptorCollectors(val collectors: List>) : - Iterable> { - override fun iterator(): Iterator> = collectors.iterator() - - @Suppress("UNCHECKED_CAST") - companion object { - - @JvmField val FUNCTIONS_AND_VARIABLES: CallableDescriptorCollectors = - CallableDescriptorCollectors(listOf( - FUNCTIONS_COLLECTOR as CallableDescriptorCollector, - VARIABLES_COLLECTOR as CallableDescriptorCollector - )) - - @JvmField val FUNCTIONS: CallableDescriptorCollectors = - CallableDescriptorCollectors(listOf(FUNCTIONS_COLLECTOR as CallableDescriptorCollector)) - - @JvmField val VARIABLES: CallableDescriptorCollectors = CallableDescriptorCollectors(listOf(VARIABLES_COLLECTOR)) - } -} - -fun CallableDescriptorCollectors.filtered(filter: (D) -> Boolean): CallableDescriptorCollectors = - CallableDescriptorCollectors(this.collectors.map { it.filtered(filter) }) - -private object FunctionCollector : CallableDescriptorCollector { - override fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection { - return lexicalScope.collectAllFromMeAndParent { - if (it is LexicalChainedScope && it.isStaticScope) { - it.getContributedFunctions(name, location).filter { it.extensionReceiverParameter == null } - } - else { - emptyList() - } - } - } - - override fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection { - return lexicalScope.collectAllFromMeAndParent { - if (it is LexicalScope && it.ownerDescriptor is FunctionDescriptor) { - it.getContributedFunctions(name, location).filter { it.extensionReceiverParameter == null } + - getConstructors(it.getContributedClassifier(name, location)) - } - else { - emptyList() - } - } - } - - override fun getNonExtensionsByName(scope: HierarchicalScope, name: Name, location: LookupLocation): Collection { - return scope.collectFunctions(name, location).filter { it.extensionReceiverParameter == null } + getConstructors(scope, name, location) - } - - override fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { - val receiverScope = receiver.memberScope - val members = receiverScope.getContributedFunctions(name, location) - val constructors = getConstructors(receiverScope.memberScopeAsImportingScope(), name, location, { !isStaticNestedClass(it) }) - - if (name == OperatorNameConventions.INVOKE && KotlinBuiltIns.isExtensionFunctionType(receiver)) { - // If we're looking for members of an extension function type, we ignore the non-extension "invoke"s - // that originate from the Function{n} class and only consider the synthesized "invoke" extensions. - // Otherwise confusing errors will be reported because the non-extension here beats the extension - // (because declarations beat synthesized members) - val (candidatesForReplacement, irrelevantInvokes) = - members.partition { it is FunctionInvokeDescriptor && it.valueParameters.isNotEmpty() } - return createSynthesizedInvokes(candidatesForReplacement) + candidatesForReplacement + irrelevantInvokes + constructors - } - - return members + constructors - } - - override fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { - return getConstructors(receiver.memberScope.memberScopeAsImportingScope(), name, location, { isStaticNestedClass(it) }) - } - - override fun getExtensionsByName(scope: HierarchicalScope, syntheticScopes: SyntheticScopes, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { - val functions = scope.collectFunctions(name, location) - val (extensions, nonExtensions) = functions.partition { it.extensionReceiverParameter != null } - val syntheticExtensions = syntheticScopes.collectSyntheticExtensionFunctions(receiverTypes, name, location) - - if (name == OperatorNameConventions.INVOKE) { - // Create synthesized "invoke" extensions for each non-extension "invoke" found in the scope - return extensions + createSynthesizedInvokes(nonExtensions) + syntheticExtensions - } - - return extensions + syntheticExtensions - } - - private fun getConstructors( - scope: HierarchicalScope, - name: Name, - location: LookupLocation, - filterClassPredicate: (ClassDescriptor) -> Boolean = { true } - ): Collection { - val classifier = scope.findClassifier(name, location) - return getConstructors(classifier, filterClassPredicate) - } - - private fun getConstructors( - classifier: ClassifierDescriptor?, - filterClassPredicate: (ClassDescriptor) -> Boolean = { true } - ): Collection { - if (classifier !is ClassDescriptor || ErrorUtils.isError(classifier) || !filterClassPredicate(classifier) - // Constructors of singletons shouldn't be callable from the code - || classifier.kind.isSingleton) { - return listOf() - } - return classifier.constructors - } - - override fun toString() = "FUNCTIONS" -} - -private object VariableCollector : CallableDescriptorCollector { - override fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection { - val result = SmartList() - result.addIfNotNull(lexicalScope.findLocalVariable(name)) - // Although local objects are prohibited, we'll include objects declared in current scope so that their usages are still resolved. - result.addIfNotNull(getContributedFakeDescriptorForObject(lexicalScope, name, location)) - return result - } - - override fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection { - return lexicalScope.collectAllFromMeAndParent { - if (it is LexicalChainedScope && it.isStaticScope) { - it.getContributedVariables(name, location) - } - else { - emptyList() - } - } - } - - private fun getContributedFakeDescriptorForObject(scope: LexicalScope, name: Name, location: LookupLocation): VariableDescriptor? { - val classifier = scope.getContributedClassifier(name, location) - if (classifier !is ClassDescriptor || !classifier.hasClassValueDescriptor) return null - return FakeCallableDescriptorForObject(classifier) - } - - private fun findFakeDescriptorForObject(scope: HierarchicalScope, name: Name, location: LookupLocation): VariableDescriptor? { - val classifier = scope.findClassifier(name, location) - if (classifier !is ClassDescriptor || !classifier.hasClassValueDescriptor) return null - - return FakeCallableDescriptorForObject(classifier) - } - - override fun getNonExtensionsByName(scope: HierarchicalScope, name: Name, location: LookupLocation): Collection { - val properties = scope.collectVariables(name, location).filter { it.extensionReceiverParameter == null } - val fakeDescriptor = findFakeDescriptorForObject(scope, name, location) - return if (fakeDescriptor != null) properties + fakeDescriptor else properties - } - - override fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { - val memberScope = receiver.memberScope - val properties = memberScope.getContributedVariables(name, location) - val fakeDescriptor = findFakeDescriptorForObject(memberScope.memberScopeAsImportingScope(), name, location) - return if (fakeDescriptor != null) properties + fakeDescriptor else properties - } - - override fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { - return listOf() - } - - override fun getExtensionsByName(scope: HierarchicalScope, syntheticScopes: SyntheticScopes, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { - // property may have an extension function type, we check the applicability later to avoid an early computing of deferred types - return scope.collectVariables(name, location) + - syntheticScopes.collectSyntheticExtensionProperties(receiverTypes, name, location) - } - - override fun toString() = "VARIABLES" -} - -private fun CallableDescriptorCollector.filtered(filter: (D) -> Boolean): CallableDescriptorCollector { - val delegate = this - return object : CallableDescriptorCollector { - override fun getLocalNonExtensionsByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection { - return delegate.getLocalNonExtensionsByName(lexicalScope, name, location).filter(filter) - } - - override fun getStaticInheritanceByName(lexicalScope: LexicalScope, name: Name, location: LookupLocation): Collection { - return delegate.getStaticInheritanceByName(lexicalScope, name, location) - } - - override fun getNonExtensionsByName(scope: HierarchicalScope, name: Name, location: LookupLocation): Collection { - return delegate.getNonExtensionsByName(scope, name, location).filter(filter) - } - - override fun getMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { - return delegate.getMembersByName(receiver, name, location).filter(filter) - } - - override fun getStaticMembersByName(receiver: KotlinType, name: Name, location: LookupLocation): Collection { - return delegate.getStaticMembersByName(receiver, name, location).filter(filter) - } - - override fun getExtensionsByName(scope: HierarchicalScope, syntheticScopes: SyntheticScopes, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { - return delegate.getExtensionsByName(scope, syntheticScopes, name, receiverTypes, location).filter(filter) - } - - override fun toString(): String { - return delegate.toString() - } - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java deleted file mode 100644 index c506472ec47..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTask.java +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright 2010-2015 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. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.resolve.calls.tasks; - -import com.intellij.util.SmartList; -import kotlin.jvm.functions.Function0; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.descriptors.CallableDescriptor; -import org.jetbrains.kotlin.psi.Call; -import org.jetbrains.kotlin.resolve.BindingTrace; -import org.jetbrains.kotlin.resolve.StatementFilter; -import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker; -import org.jetbrains.kotlin.resolve.calls.context.*; -import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments; -import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall; -import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; -import org.jetbrains.kotlin.resolve.scopes.LexicalScope; -import org.jetbrains.kotlin.types.KotlinType; - -import java.util.Collection; - -/** - * Stores candidates for call resolution. - */ -public class ResolutionTask extends CallResolutionContext> { - private final Function0>> lazyCandidates; - private final Collection> resolvedCalls; - public final TracingStrategy tracing; - - private ResolutionTask( - @NotNull Function0>> lazyCandidates, - @NotNull TracingStrategy tracing, - @NotNull BindingTrace trace, - @NotNull LexicalScope scope, - @NotNull Call call, - @NotNull KotlinType expectedType, - @NotNull DataFlowInfo dataFlowInfo, - @NotNull ContextDependency contextDependency, - @NotNull CheckArgumentTypesMode checkArguments, - @NotNull ResolutionResultsCache resolutionResultsCache, - @Nullable MutableDataFlowInfoForArguments dataFlowInfoForArguments, - @NotNull CallChecker callChecker, - @NotNull StatementFilter statementFilter, - @NotNull Collection> resolvedCalls, - boolean isAnnotationContext, - boolean isDebuggerContext, - boolean collectAllCandidates, - @NotNull CallPosition callPosition - ) { - super(trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, resolutionResultsCache, - dataFlowInfoForArguments, callChecker, statementFilter, isAnnotationContext, isDebuggerContext, collectAllCandidates, callPosition); - this.lazyCandidates = lazyCandidates; - this.resolvedCalls = resolvedCalls; - this.tracing = tracing; - } - - public ResolutionTask( - @NotNull BasicCallResolutionContext context, - @NotNull TracingStrategy tracing, - @NotNull Function0>> lazyCandidates - ) { - this(lazyCandidates, tracing, - context.trace, context.scope, context.call, - context.expectedType, context.dataFlowInfo, context.contextDependency, context.checkArguments, - context.resolutionResultsCache, context.dataFlowInfoForArguments, - context.callChecker, - context.statementFilter, new SmartList>(), - context.isAnnotationContext, context.isDebuggerContext, context.collectAllCandidates, context.callPosition); - } - - @NotNull - public Collection> getCandidates() { - return lazyCandidates.invoke(); - } - - public void addResolvedCall(@NotNull MutableResolvedCall resolvedCall) { - resolvedCalls.add(resolvedCall); - } - - @NotNull - public Collection> getResolvedCalls() { - return resolvedCalls; - } - - @Override - protected ResolutionTask create( - @NotNull BindingTrace trace, - @NotNull LexicalScope scope, - @NotNull DataFlowInfo dataFlowInfo, - @NotNull KotlinType expectedType, - @NotNull ContextDependency contextDependency, - @NotNull ResolutionResultsCache resolutionResultsCache, - @NotNull StatementFilter statementFilter, - boolean collectAllCandidates, - @NotNull CallPosition callPosition - ) { - return new ResolutionTask( - lazyCandidates, tracing, trace, scope, call, expectedType, dataFlowInfo, contextDependency, checkArguments, - resolutionResultsCache, dataFlowInfoForArguments, - callChecker, - statementFilter, resolvedCalls, - isAnnotationContext, isDebuggerContext, collectAllCandidates, callPosition); - } - - @Override - public String toString() { - return lazyCandidates.toString(); - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt deleted file mode 100644 index 5e3a245face..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/ResolutionTaskHolder.kt +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright 2010-2015 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. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.resolve.calls.tasks - -import org.jetbrains.kotlin.descriptors.CallableDescriptor -import org.jetbrains.kotlin.psi.KtPsiUtil -import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext -import org.jetbrains.kotlin.storage.StorageManager -import java.util.ArrayList -import org.jetbrains.kotlin.utils.toReadOnlyList - -class ResolutionTaskHolder( - private val storageManager: StorageManager, - private val basicCallResolutionContext: BasicCallResolutionContext, - private val priorityProvider: ResolutionTaskHolder.PriorityProvider>, - private val tracing: TracingStrategy -) { - private val candidatesList = ArrayList<() -> Collection>>() - private var internalTasks: List>? = null - - fun addCandidates(lazyCandidates: () -> Collection>) { - assertNotFinished() - candidatesList.add(storageManager.createLazyValue { lazyCandidates().toReadOnlyList() }) - } - - private fun assertNotFinished() { - assert(internalTasks == null) { "Can't add candidates after the resulting tasks were computed." } - } - - fun getTasks(): List> { - if (internalTasks == null) { - val tasks = ArrayList>() - for (priority in (0..priorityProvider.getMaxPriority()).reversed()) { - for (candidateIndex in candidatesList.indices) { - val lazyCandidates = { - candidatesList[candidateIndex]().filter { priorityProvider.getPriority(it) == priority }.toReadOnlyList() - } - tasks.add(ResolutionTask(basicCallResolutionContext, tracing, lazyCandidates)) - } - } - - internalTasks = tasks - } - return internalTasks!! - } - - interface PriorityProvider { - fun getPriority(candidate: D): Int - - fun getMaxPriority(): Int - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt deleted file mode 100644 index 14ceca341c8..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt +++ /dev/null @@ -1,538 +0,0 @@ -/* - * Copyright 2010-2016 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. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.resolve.calls.tasks - -import com.google.common.collect.Lists -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus -import org.jetbrains.kotlin.psi.Call -import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getUnaryPlusOrMinusOperatorFunctionName -import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isConventionCall -import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isInfixCall -import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isOrOverridesSynthesized -import org.jetbrains.kotlin.resolve.calls.callUtil.createLookupLocation -import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext -import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext -import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastManager -import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind.* -import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollector -import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollectors -import org.jetbrains.kotlin.resolve.calls.tasks.collectors.filtered -import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject -import org.jetbrains.kotlin.resolve.descriptorUtil.hasLowPriorityInOverloadResolution -import org.jetbrains.kotlin.resolve.scopes.ImportingScope -import org.jetbrains.kotlin.resolve.scopes.LexicalScope -import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes -import org.jetbrains.kotlin.resolve.scopes.receivers.* -import org.jetbrains.kotlin.resolve.scopes.utils.getImplicitReceiversHierarchy -import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsImportingScope -import org.jetbrains.kotlin.resolve.selectMostSpecificInEachOverridableGroup -import org.jetbrains.kotlin.storage.StorageManager -import org.jetbrains.kotlin.types.ErrorUtils -import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.TypeSubstitutor -import org.jetbrains.kotlin.types.checker.KotlinTypeChecker -import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils -import org.jetbrains.kotlin.types.isDynamic -import org.jetbrains.kotlin.util.OperatorNameConventions - -class TaskPrioritizer( - private val storageManager: StorageManager, - private val smartCastManager: SmartCastManager, - private val dynamicCallableDescriptors: DynamicCallableDescriptors, - private val syntheticScopes: SyntheticScopes -) { - - fun computePrioritizedTasks( - context: BasicCallResolutionContext, - name: Name, - tracing: TracingStrategy, - callableDescriptorCollectors: CallableDescriptorCollectors - ): List> { - val explicitReceiver = context.call.explicitReceiver - val result = ResolutionTaskHolder(storageManager, context, PriorityProviderImpl(context), tracing) - val taskPrioritizerContext = TaskPrioritizerContext(name, result, context, context.scope, callableDescriptorCollectors) - - when (explicitReceiver) { - is QualifierReceiver -> { - val qualifierReceiver: QualifierReceiver = explicitReceiver - val receiverScope = LexicalScope.empty(qualifierReceiver.getNestedClassesAndPackageMembersScope().memberScopeAsImportingScope(), - qualifierReceiver.descriptor) - doComputeTasks(null, taskPrioritizerContext.replaceScope(receiverScope)) - computeTasksForClassObjectReceiver(qualifierReceiver, taskPrioritizerContext) - } - is ReceiverValue? -> { - doComputeTasks(explicitReceiver, taskPrioritizerContext) - - // Temporary fix for code migration (unaryPlus()/unaryMinus()) - val unaryConventionName = getUnaryPlusOrMinusOperatorFunctionName(context.call) - if (unaryConventionName != null) { - val deprecatedName = if (name == OperatorNameConventions.UNARY_PLUS) - OperatorNameConventions.PLUS - else - OperatorNameConventions.MINUS - - val additionalContext = TaskPrioritizerContext(deprecatedName, result, context, context.scope, callableDescriptorCollectors) - doComputeTasks(explicitReceiver, additionalContext) - } - } - } - - return result.getTasks() - } - - private fun computeTasksForClassObjectReceiver( - qualifier: Qualifier, - taskPrioritizerContext: TaskPrioritizerContext - ) { - if (qualifier is ClassQualifier) { - val companionObject = qualifier.classValueReceiver ?: return - val classifierDescriptor = qualifier.classifier - doComputeTasks(companionObject, taskPrioritizerContext.filterCollectors { - when { - classifierDescriptor is ClassDescriptor && classifierDescriptor.companionObjectDescriptor != null -> { - // nested classes and objects should not be accessible via short reference to companion object - it !is ConstructorDescriptor && it !is FakeCallableDescriptorForObject - } - DescriptorUtils.isEnumEntry(classifierDescriptor) -> { - // objects nested in enum should not be accessible via enum entries reference - it !is FakeCallableDescriptorForObject - } - else -> true - } - }) - } - } - - private fun doComputeTasks(receiver: ReceiverValue?, c: TaskPrioritizerContext) { - ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() - - val receiverWithTypes = ReceiverWithTypes(receiver, c.context) - - val resolveInvoke = c.context.call.dispatchReceiver != null - if (resolveInvoke) { - addCandidatesForInvoke(receiverWithTypes, c) - return - } - val implicitReceivers = c.scope.getImplicitReceiversHierarchy().map { it.value } - if (receiver != null) { - addCandidatesForExplicitReceiver(receiverWithTypes, implicitReceivers, c, isExplicit = true) - addMembers(receiverWithTypes, c, staticMembers = true, isExplicit = true) - return - } - addCandidatesForNoReceiver(implicitReceivers, c) - } - - private inner class ReceiverWithTypes( - val value: ReceiverValue?, - private val context: ResolutionContext<*> - ) { - val types: Collection by lazy { smartCastManager.getSmartCastVariants(value!!, context) } - } - - private fun addCandidatesForExplicitReceiver( - explicitReceiver: ReceiverWithTypes, - implicitReceivers: Collection, - c: TaskPrioritizerContext, - isExplicit: Boolean - ) { - val explicitReceiverTypeIsDynamic = explicitReceiver.value!!.type.isDynamic() - - fun addMembersAndExtensionsWithFilter(filter: (CallableDescriptor) -> Boolean) { - // If the explicit receiver is erroneous, an error function is returned by getMembersByName(). - // An error function should not be sorted out by our custom filters to prevent looking for extension functions. - if (explicitReceiver.types.any { it.isError }) return - - addMembers(explicitReceiver, c, staticMembers = false, isExplicit = isExplicit, filter = filter) - if (!explicitReceiverTypeIsDynamic) { - addExtensionCandidates(explicitReceiver, implicitReceivers, c, isExplicit, filter) - } - } - - // Members and extensions with 'operator' and 'infix' modifiers have higher priority - if (isConventionCall(c.context.call)) { - addMembersAndExtensionsWithFilter { d: CallableDescriptor -> d is FunctionDescriptor && d.isOperator } - } - if (isInfixCall(c.context.call)) { - addMembersAndExtensionsWithFilter { d: CallableDescriptor -> d is FunctionDescriptor && d.isInfix } - } - - addMembers(explicitReceiver, c, staticMembers = false, isExplicit = isExplicit) - - if (explicitReceiverTypeIsDynamic) { - addCandidatesForDynamicReceiver(explicitReceiver, implicitReceivers, c, isExplicit) - } - else { - addExtensionCandidates(explicitReceiver, implicitReceivers, c, isExplicit) - } - } - - private fun addExtensionCandidates( - explicitReceiver: ReceiverWithTypes, - implicitReceivers: Collection, - c: TaskPrioritizerContext, - isExplicit: Boolean, - filter: ((CallableDescriptor) -> Boolean)? = null - ) { - for (callableDescriptorCollector in c.callableDescriptorCollectors) { - //member extensions - for (implicitReceiver in implicitReceivers) { - addMemberExtensionCandidates( - implicitReceiver, - explicitReceiver, - callableDescriptorCollector, - c, - createKind(EXTENSION_RECEIVER, isExplicit) - ) - } - //extensions - c.result.addCandidates { - val extensions = callableDescriptorCollector.getExtensionsByName( - c.scope, syntheticScopes, c.name, explicitReceiver.types, createLookupLocation(c)) - val filteredExtensions = if (filter == null) extensions else extensions.filter(filter) - - convertWithImpliedThis( - c.scope, - explicitReceiver.value, - filteredExtensions, - createKind(EXTENSION_RECEIVER, isExplicit), - c.context.call - ) - } - } - } - - private fun addMembers( - explicitReceiver: ReceiverWithTypes, - c: TaskPrioritizerContext, - staticMembers: Boolean, - isExplicit: Boolean, - filter: ((CallableDescriptor) -> Boolean)? = null - ) { - for (callableDescriptorCollector in c.callableDescriptorCollectors) { - c.result.addCandidates { - val members = Lists.newArrayList>() - for (type in explicitReceiver.types) { - val membersForThisVariant = if (staticMembers) { - callableDescriptorCollector.getStaticMembersByName(type, c.name, createLookupLocation(c)) - } - else { - callableDescriptorCollector.getMembersByName(type, c.name, createLookupLocation(c)) - } - val filteredMembers = if (filter == null) membersForThisVariant else membersForThisVariant.filter(filter) - - val dispatchReceiver = - if (explicitReceiver.value is ImplicitClassReceiver && type != explicitReceiver.value.type) { - CastImplicitClassReceiver(explicitReceiver.value.classDescriptor, type) - } - else { - explicitReceiver.value - } - convertWithReceivers( - filteredMembers, - dispatchReceiver, - null, - members, - createKind(DISPATCH_RECEIVER, isExplicit), - c.context.call - ) - } - - if (explicitReceiver.types.size > 1) { - members.retainAll( members.selectMostSpecificInEachOverridableGroup { descriptor } ) - } - - members - } - } - } - - private fun addCandidatesForDynamicReceiver( - explicitReceiver: ReceiverWithTypes, - implicitReceivers: Collection, - c: TaskPrioritizerContext, - isExplicit: Boolean - ) { - val onlyDynamicReceivers = c.replaceCollectors(c.callableDescriptorCollectors.onlyDynamicReceivers()) - addExtensionCandidates(explicitReceiver, implicitReceivers, onlyDynamicReceivers, isExplicit) - - c.result.addCandidates { - val dynamicScope = dynamicCallableDescriptors.createDynamicDescriptorScope(c.context.call, c.scope.ownerDescriptor) - - val dynamicDescriptors = c.callableDescriptorCollectors.flatMap { - it.getNonExtensionsByName(dynamicScope.memberScopeAsImportingScope(), c.name, createLookupLocation(c)) - } - - convertWithReceivers(dynamicDescriptors, explicitReceiver.value, null, createKind(DISPATCH_RECEIVER, isExplicit), c.context.call) - } - } - - private fun createKind(kind: ExplicitReceiverKind, isExplicit: Boolean): ExplicitReceiverKind { - if (isExplicit) return kind - return ExplicitReceiverKind.NO_EXPLICIT_RECEIVER - } - - private fun addMemberExtensionCandidates( - dispatchReceiver: ReceiverValue, - receiverParameter: ReceiverWithTypes, - callableDescriptorCollector: CallableDescriptorCollector, - c: TaskPrioritizerContext, - receiverKind: ExplicitReceiverKind - ) { - c.result.addCandidates { - val memberExtensions = - callableDescriptorCollector.getExtensionsByName(dispatchReceiver.type.memberScope.memberScopeAsImportingScope(), syntheticScopes, c.name, receiverParameter.types, createLookupLocation(c)) - convertWithReceivers(memberExtensions, dispatchReceiver, receiverParameter.value, receiverKind, c.context.call) - } - } - - private fun addCandidatesForNoReceiver( - implicitReceivers: Collection, - c: TaskPrioritizerContext - ) { - val lookupLocation = createLookupLocation(c) - - //locals - c.callableDescriptorCollectors.forEach { - c.result.addCandidates { - convertWithImpliedThisAndNoReceiver( - c.scope, - it.getLocalNonExtensionsByName(c.scope, c.name, lookupLocation), - c.context.call - ) - } - } - - val implicitReceiversWithTypes = implicitReceivers.map { ReceiverWithTypes(it, c.context) } - - //try all implicit receivers as explicit - for (implicitReceiver in implicitReceiversWithTypes) { - addCandidatesForExplicitReceiver(implicitReceiver, implicitReceivers, c, isExplicit = false) - } - - // static members hack - c.callableDescriptorCollectors.forEach { - c.result.addCandidates { - val descriptors = it.getStaticInheritanceByName(c.scope, c.name, lookupLocation) - convertWithImpliedThisAndNoReceiver(c.scope, descriptors, c.context.call) - } - } - - //nonlocals - c.callableDescriptorCollectors.forEach { - c.result.addCandidates { - val descriptors = it.getNonExtensionsByName(c.scope, c.name, lookupLocation) - .filter { c.scope is ImportingScope || !ExpressionTypingUtils.isLocal(c.scope.ownerDescriptor, it) } - convertWithImpliedThisAndNoReceiver(c.scope, descriptors, c.context.call) - } - } - - //static (only for better error reporting) - for (implicitReceiver in implicitReceiversWithTypes) { - addMembers(implicitReceiver, c, staticMembers = true, isExplicit = false) - } - } - - private fun createLookupLocation(c: TaskPrioritizerContext<*, *>) = c.context.call.createLookupLocation() - - private fun addCandidatesForInvoke(explicitReceiver: ReceiverWithTypes, c: TaskPrioritizerContext) { - val implicitReceivers = c.scope.getImplicitReceiversHierarchy().map { it.value } - - // For 'a.foo()' where foo has function type, - // a is explicitReceiver, foo is variableReceiver. - val variableReceiver = c.context.call.dispatchReceiver - assert(variableReceiver != null) { "'Invoke' call hasn't got variable receiver" } - - // For invocation a.foo() explicit receiver 'a' - // can be a receiver for 'foo' variable - // or for 'invoke' function. - - // (1) a.foo + foo.invoke() - if (explicitReceiver.value == null) { - addCandidatesForExplicitReceiver(ReceiverWithTypes(variableReceiver!!, c.context), implicitReceivers, c, isExplicit = true) - } - - // (2) foo + a.invoke() - - // 'invoke' is member extension to explicit receiver while variable receiver is 'this object' - //trait A - //trait Foo { fun A.invoke() } - - if (explicitReceiver.value != null) { - //a.foo() - addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver!!, explicitReceiver, c, BOTH_RECEIVERS) - return - } - // with (a) { foo() } - for (implicitReceiver in implicitReceivers) { - addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver(variableReceiver!!, ReceiverWithTypes(implicitReceiver, c.context), c, DISPATCH_RECEIVER) - } - } - - private fun addCandidatesWhenInvokeIsMemberAndExtensionToExplicitReceiver( - dispatchReceiver: ReceiverValue, - receiverParameter: ReceiverWithTypes, - c: TaskPrioritizerContext, - receiverKind: ExplicitReceiverKind - ) { - for (callableDescriptorCollector in c.callableDescriptorCollectors) { - addMemberExtensionCandidates(dispatchReceiver, receiverParameter, callableDescriptorCollector, c, receiverKind) - } - } - - 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 fun convertWithReceivers( - descriptors: Collection, - dispatchReceiver: ReceiverValue?, - extensionReceiver: ReceiverValue?, - result: MutableCollection>, - explicitReceiverKind: ExplicitReceiverKind, - call: Call - ) { - for (descriptor in descriptors) { - val candidate = ResolutionCandidate.create(call, descriptor) - candidate.dispatchReceiver = dispatchReceiver - candidate.setReceiverArgument(extensionReceiver) - candidate.explicitReceiverKind = explicitReceiverKind - result.add(candidate) - } - } - - private fun convertWithImpliedThisAndNoReceiver( - scope: LexicalScope, - descriptors: Collection, - call: Call, - knownSubstitutor: TypeSubstitutor? = null - ): Collection> { - return convertWithImpliedThis(scope, null, descriptors, NO_EXPLICIT_RECEIVER, call, knownSubstitutor) - } - - private fun convertWithImpliedThis( - scope: LexicalScope, - receiverValue: ReceiverValue?, - descriptors: Collection, - receiverKind: ExplicitReceiverKind, - call: Call, - knownSubstitutor: TypeSubstitutor? = null - ): Collection> { - val result = Lists.newArrayList>() - for (descriptor in descriptors) { - val candidate = ResolutionCandidate.create(call, descriptor, null, receiverValue, receiverKind, knownSubstitutor) - if (setImpliedThis(scope, candidate, knownSubstitutor)) { - result.add(candidate) - } - } - return result - } - - private fun setImpliedThis( - scope: LexicalScope, - candidate: ResolutionCandidate, - knownSubstitutor: TypeSubstitutor? - ): Boolean { - val dispatchReceiver = candidate.descriptor.dispatchReceiverParameter ?: return true - val substitutedDispatchReceiver = knownSubstitutor?.let { - dispatchReceiver.substitute(it) ?: return false - } ?: dispatchReceiver - - val receivers = scope.getImplicitReceiversHierarchy() - for (receiver in receivers) { - if (KotlinTypeChecker.DEFAULT.isSubtypeOf(receiver.type, substitutedDispatchReceiver.type)) { - candidate.dispatchReceiver = substitutedDispatchReceiver.value - return true - } - } - return false - } - - fun computePrioritizedTasksFromCandidates( - context: BasicCallResolutionContext, - candidates: Collection>, - tracing: TracingStrategy - ): List> { - val result = ResolutionTaskHolder(storageManager, context, PriorityProviderImpl(context), tracing) - result.addCandidates { - candidates - } - return result.getTasks() - } - - private class PriorityProviderImpl(private val context: BasicCallResolutionContext) : - ResolutionTaskHolder.PriorityProvider> { - - override fun getPriority(candidate: ResolutionCandidate) - = if (hasImplicitDynamicReceiver(candidate)) 0 - else (if (!isVisible(candidate) || hasLowPriority(candidate)) 0 else 2) + (if (isSynthesized(candidate)) 0 else 1) - - override fun getMaxPriority() = 3 - - private fun isVisible(candidate: ResolutionCandidate?): Boolean { - if (candidate == null) return false - val candidateDescriptor = candidate.descriptor - if (ErrorUtils.isError(candidateDescriptor)) return true - return Visibilities.isVisible(candidate.dispatchReceiver, candidateDescriptor, context.scope.ownerDescriptor) - } - - private fun hasLowPriority(candidate: ResolutionCandidate?): Boolean { - if (candidate == null) return false - return candidate.descriptor.hasLowPriorityInOverloadResolution() - } - - private fun isSynthesized(candidate: ResolutionCandidate): Boolean { - val descriptor = candidate.descriptor - return descriptor is CallableMemberDescriptor && isOrOverridesSynthesized(descriptor) - } - - fun hasImplicitDynamicReceiver(candidate: ResolutionCandidate): Boolean { - return (!candidate.explicitReceiverKind.isDispatchReceiver || candidate.call.explicitReceiver == null) - && candidate.descriptor.isDynamic() - } - } - - private class TaskPrioritizerContext( - val name: Name, - val result: ResolutionTaskHolder, - val context: BasicCallResolutionContext, - val scope: LexicalScope, - val callableDescriptorCollectors: CallableDescriptorCollectors - ) { - fun replaceScope(newScope: LexicalScope): TaskPrioritizerContext { - return TaskPrioritizerContext(name, result, context, newScope, callableDescriptorCollectors) - } - - fun replaceCollectors(newCollectors: CallableDescriptorCollectors): TaskPrioritizerContext { - return TaskPrioritizerContext(name, result, context, scope, newCollectors) - } - - fun filterCollectors(filter: (D) -> Boolean): TaskPrioritizerContext { - return TaskPrioritizerContext(name, result, context, scope, callableDescriptorCollectors.filtered(filter)) - } - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt index 88173f70e4e..c3ad47d65c5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. + * Copyright 2010-2016 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. @@ -25,12 +25,8 @@ import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.DescriptorFactory -import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollector -import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollectors import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns -import org.jetbrains.kotlin.resolve.scopes.HierarchicalScope import org.jetbrains.kotlin.resolve.scopes.MemberScopeImpl -import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.Variance @@ -227,14 +223,3 @@ fun DeclarationDescriptor.isDynamic(): Boolean { return dispatchReceiverParameter != null && dispatchReceiverParameter.type.isDynamic() } -class CollectorForDynamicReceivers(val delegate: CallableDescriptorCollector) : CallableDescriptorCollector by delegate { - override fun getExtensionsByName(scope: HierarchicalScope, syntheticScopes: SyntheticScopes, name: Name, receiverTypes: Collection, location: LookupLocation): Collection { - return delegate.getExtensionsByName(scope, syntheticScopes, name, receiverTypes, location).filter { - it.extensionReceiverParameter?.type?.isDynamic() ?: false - } - } -} - -fun CallableDescriptorCollectors.onlyDynamicReceivers(): CallableDescriptorCollectors { - return CallableDescriptorCollectors(this.map { CollectorForDynamicReceivers(it) }) -} diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt b/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt index 0be9fd952d6..41de5df36a9 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt +++ b/compiler/tests/org/jetbrains/kotlin/checkers/LazyOperationsLog.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2015 JetBrains s.r.o. + * Copyright 2010-2016 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. @@ -22,12 +22,9 @@ import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl import org.jetbrains.kotlin.load.java.structure.impl.JavaTypeImpl import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.psi.debugText.getDebugText import org.jetbrains.kotlin.renderer.DescriptorRenderer import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionCandidate -import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionTaskHolder import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.deserialization.DeserializationContext @@ -189,7 +186,6 @@ class LazyOperationsLog( }.appendQuoted() } o is ResolutionCandidate<*> -> DescriptorRenderer.COMPACT.render(o.descriptor).appendQuoted() - o is ResolutionTaskHolder<*, *> -> o.field("basicCallResolutionContext").call.callElement.getDebugText().appendQuoted() } return sb.toString() }