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 2978b362a2c..17758d2ddd0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -641,7 +641,7 @@ public class CallResolver { } OverloadResolutionResultsImpl results = resolutionResultsHandler.computeResultAndReportErrors( - task, task.getResolvedCalls()); + task, task.tracing, task.getResolvedCalls()); if (!results.isSingleResult() && !results.isIncomplete()) { argumentTypeResolver.checkTypesWithNoCallee(task.toBasic()); } @@ -666,7 +666,7 @@ public class CallResolver { Collection> contexts = callTransformer.createCallContexts(resolutionCandidate, task, candidateTrace, candidateResolveMode); for (CallCandidateResolutionContext context : contexts) { - candidateResolver.performResolutionForCandidateCall(context, task); + candidateResolver.performResolutionForCandidateCall(context, task.checkArguments); candidateResolutionContexts.add(context); } return Unit.INSTANCE$; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt index 86324e9facd..3043fdf963a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt @@ -43,7 +43,6 @@ import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.* import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastManager -import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionTask import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue @@ -63,7 +62,7 @@ public class CandidateResolver( public fun performResolutionForCandidateCall( context: CallCandidateResolutionContext, - task: ResolutionTask + checkArguments: CheckArgumentTypesMode ): Unit = with(context) { ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() @@ -79,7 +78,7 @@ public class CandidateResolver( checkVisibility() - when (task.checkArguments) { + when (checkArguments) { CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS -> mapArguments() CheckArgumentTypesMode.CHECK_CALLABLE_TYPE -> diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java index a41141bb544..a6f3227ec94 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/results/ResolutionResultsHandler.java @@ -19,11 +19,13 @@ package org.jetbrains.kotlin.resolve.calls.results; import com.google.common.collect.Sets; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.descriptors.CallableDescriptor; +import org.jetbrains.kotlin.resolve.BindingTrace; import org.jetbrains.kotlin.resolve.OverrideResolver; import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt; +import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext; import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode; import org.jetbrains.kotlin.resolve.calls.model.MutableResolvedCall; -import org.jetbrains.kotlin.resolve.calls.tasks.ResolutionTask; +import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy; import java.util.Collection; import java.util.EnumSet; @@ -42,10 +44,11 @@ public class ResolutionResultsHandler { @NotNull public OverloadResolutionResultsImpl computeResultAndReportErrors( - @NotNull ResolutionTask task, + @NotNull CallResolutionContext context, + @NotNull TracingStrategy tracing, @NotNull Collection> candidates ) { - boolean resolveOverloads = task.checkArguments == CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS; // todo rename CheckArgumentTypesMode + boolean resolveOverloads = context.checkArguments == CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS; // todo rename CheckArgumentTypesMode Set> successfulCandidates = Sets.newLinkedHashSet(); Set> failedCandidates = Sets.newLinkedHashSet(); @@ -70,22 +73,23 @@ public class ResolutionResultsHandler { // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific if (!successfulCandidates.isEmpty() || !incompleteCandidates.isEmpty()) { - return computeSuccessfulResult(task, successfulCandidates, incompleteCandidates, resolveOverloads); + return computeSuccessfulResult(context, tracing, successfulCandidates, incompleteCandidates, resolveOverloads); } else if (!failedCandidates.isEmpty()) { - return computeFailedResult(task, failedCandidates, resolveOverloads); + return computeFailedResult(tracing, context.trace, failedCandidates, resolveOverloads); } if (!candidatesWithWrongReceiver.isEmpty()) { - task.tracing.unresolvedReferenceWrongReceiver(task.trace, candidatesWithWrongReceiver); + tracing.unresolvedReferenceWrongReceiver(context.trace, candidatesWithWrongReceiver); return OverloadResolutionResultsImpl.candidatesWithWrongReceiver(candidatesWithWrongReceiver); } - task.tracing.unresolvedReference(task.trace); + tracing.unresolvedReference(context.trace); return OverloadResolutionResultsImpl.nameNotFound(); } @NotNull private OverloadResolutionResultsImpl computeSuccessfulResult( - @NotNull ResolutionTask task, + @NotNull CallResolutionContext context, + @NotNull TracingStrategy tracing, @NotNull Set> successfulCandidates, @NotNull Set> incompleteCandidates, boolean resolveOverloads @@ -96,23 +100,23 @@ public class ResolutionResultsHandler { OverloadResolutionResultsImpl results = chooseAndReportMaximallySpecific(successfulAndIncomplete, true, resolveOverloads); if (results.isSingleResult()) { MutableResolvedCall resultingCall = results.getResultingCall(); - resultingCall.getTrace().moveAllMyDataTo(task.trace); + resultingCall.getTrace().moveAllMyDataTo(context.trace); if (resultingCall.getStatus() == INCOMPLETE_TYPE_INFERENCE) { return OverloadResolutionResultsImpl.incompleteTypeInference(resultingCall); } } if (results.isAmbiguity()) { - task.tracing.recordAmbiguity(task.trace, results.getResultingCalls()); + tracing.recordAmbiguity(context.trace, results.getResultingCalls()); boolean allCandidatesIncomplete = allIncomplete(results.getResultingCalls()); // This check is needed for the following case: // x.foo(unresolved) -- if there are multiple foo's, we'd report an ambiguity, and it does not make sense here - if (task.checkArguments != CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS || - !CallUtilKt.hasUnresolvedArguments(task.call, task)) { + if (context.checkArguments != CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS || + !CallUtilKt.hasUnresolvedArguments(context.call, context)) { if (allCandidatesIncomplete) { - task.tracing.cannotCompleteResolve(task.trace, results.getResultingCalls()); + tracing.cannotCompleteResolve(context.trace, results.getResultingCalls()); } else { - task.tracing.ambiguity(task.trace, results.getResultingCalls()); + tracing.ambiguity(context.trace, results.getResultingCalls()); } } if (allCandidatesIncomplete) { @@ -124,7 +128,8 @@ public class ResolutionResultsHandler { @NotNull private OverloadResolutionResultsImpl computeFailedResult( - @NotNull ResolutionTask task, + @NotNull TracingStrategy tracing, + @NotNull BindingTrace trace, @NotNull Set> failedCandidates, boolean resolveOverloads ) { @@ -141,34 +146,35 @@ public class ResolutionResultsHandler { } if (!thisLevel.isEmpty()) { if (severityLevel.contains(ARGUMENTS_MAPPING_ERROR)) { - return recordFailedInfo(task, thisLevel); + return recordFailedInfo(tracing, trace, thisLevel); } OverloadResolutionResultsImpl results = chooseAndReportMaximallySpecific(thisLevel, false, resolveOverloads); - return recordFailedInfo(task, results.getResultingCalls()); + return recordFailedInfo(tracing, trace, results.getResultingCalls()); } } assert false : "Should not be reachable, cause every status must belong to some level"; Set> noOverrides = OverrideResolver.filterOutOverridden(failedCandidates, MAP_TO_CANDIDATE); - return recordFailedInfo(task, noOverrides); + return recordFailedInfo(tracing, trace, noOverrides); } - return recordFailedInfo(task, failedCandidates); + return recordFailedInfo(tracing, trace, failedCandidates); } @NotNull private static OverloadResolutionResultsImpl recordFailedInfo( - @NotNull ResolutionTask task, + @NotNull TracingStrategy tracing, + @NotNull BindingTrace trace, @NotNull Collection> candidates ) { if (candidates.size() == 1) { MutableResolvedCall failed = candidates.iterator().next(); - failed.getTrace().moveAllMyDataTo(task.trace); + failed.getTrace().moveAllMyDataTo(trace); return OverloadResolutionResultsImpl.singleFailedCandidate(failed); } - task.tracing.noneApplicable(task.trace, candidates); - task.tracing.recordAmbiguity(task.trace, candidates); + tracing.noneApplicable(trace, candidates); + tracing.recordAmbiguity(trace, candidates); return OverloadResolutionResultsImpl.manyFailedCandidates(candidates); }