diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 17e9aa6a456..defea4e3aab 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1129,7 +1129,7 @@ public class ExpressionCodegen extends JetVisitor { } private int pushMethodArguments(JetCallElement expression, List valueParameterTypes) { - ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression()); + ResolvedCallImpl resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression()); List args = expression.getValueArguments(); if(resolvedCall != null) { Map valueArguments = resolvedCall.getValueArguments(); @@ -1791,7 +1791,7 @@ public class ExpressionCodegen extends JetVisitor { private void pushTypeArguments(JetCallElement expression) { // todo when frontend calculates -// ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression()); +// ResolvedCallImpl resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression()); // if(resolvedCall != null) { // Map typeArguments = resolvedCall.getTypeArguments(); // CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java index b9d4050f915..23126722df9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java @@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.diagnostics; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; import org.jetbrains.jet.resolve.DescriptorRenderer; import java.util.Collection; @@ -10,7 +10,7 @@ import java.util.Collection; /** * @author abreslav */ -public class AmbiguousDescriptorDiagnosticFactory extends ParameterizedDiagnosticFactory1>> { +public class AmbiguousDescriptorDiagnosticFactory extends ParameterizedDiagnosticFactory1>> { public static AmbiguousDescriptorDiagnosticFactory create(String messageTemplate) { return new AmbiguousDescriptorDiagnosticFactory(messageTemplate); } @@ -20,9 +20,9 @@ public class AmbiguousDescriptorDiagnosticFactory extends ParameterizedDiagnosti } @Override - protected String makeMessageFor(@NotNull Collection> argument) { + protected String makeMessageFor(@NotNull Collection> argument) { StringBuilder stringBuilder = new StringBuilder("\n"); - for (ResolvedCall call : argument) { + for (ResolvedCallImpl call : argument) { stringBuilder.append(DescriptorRenderer.TEXT.render(call.getResultingDescriptor())).append("\n"); } return stringBuilder.toString(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java index e5d49d0c837..8c7fcf345a1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -6,7 +6,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.DeferredType; @@ -27,9 +27,9 @@ public interface BindingContext { WritableSlice EXPRESSION_TYPE = new BasicWritableSlice("EXPRESSION_TYPE", RewritePolicy.DO_NOTHING); WritableSlice REFERENCE_TARGET = new BasicWritableSlice("REFERENCE_TARGET", RewritePolicy.DO_NOTHING); - WritableSlice> RESOLVED_CALL = new BasicWritableSlice>("RESOLVED_CALL", RewritePolicy.DO_NOTHING); + WritableSlice> RESOLVED_CALL = new BasicWritableSlice>("RESOLVED_CALL", RewritePolicy.DO_NOTHING); - WritableSlice>> AMBIGUOUS_REFERENCE_TARGET = new BasicWritableSlice>>("AMBIGUOUS_REFERENCE_TARGET", RewritePolicy.DO_NOTHING); + WritableSlice>> AMBIGUOUS_REFERENCE_TARGET = new BasicWritableSlice>>("AMBIGUOUS_REFERENCE_TARGET", RewritePolicy.DO_NOTHING); WritableSlice LOOP_RANGE_ITERATOR = Slices.createSimpleSlice("LOOP_RANGE_ITERATOR"); WritableSlice LOOP_RANGE_HAS_NEXT = Slices.createSimpleSlice("LOOP_RANGE_HAS_NEXT"); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 423c44cbfac..3840d59e444 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -27,8 +27,8 @@ import java.util.*; import static org.jetbrains.jet.lang.diagnostics.Errors.*; import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.resolve.calls.ResolutionStatus.*; -import static org.jetbrains.jet.lang.resolve.calls.ResolvedCall.MAP_TO_CANDIDATE; -import static org.jetbrains.jet.lang.resolve.calls.ResolvedCall.MAP_TO_RESULT; +import static org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl.MAP_TO_CANDIDATE; +import static org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl.MAP_TO_RESULT; import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; @@ -171,7 +171,7 @@ public class CallResolver { trace.report(NO_CONSTRUCTOR.on(reportAbsenceOn)); return checkArgumentTypesAndFail(trace, scope, call); } - prioritizedTasks = Collections.singletonList(new ResolutionTask(ResolvedCall.convertCollection(constructors), call, DataFlowInfo.EMPTY)); + prioritizedTasks = Collections.singletonList(new ResolutionTask(ResolvedCallImpl.convertCollection(constructors), call, DataFlowInfo.EMPTY)); } else { throw new UnsupportedOperationException("Type argument inference not implemented for " + call); @@ -194,12 +194,12 @@ public class CallResolver { @NotNull JetType expectedType, @NotNull final List> prioritizedTasks, // high to low priority @NotNull final JetReferenceExpression reference) { - ResolvedCall resolvedCall = doResolveCall(trace, scope, call, expectedType, prioritizedTasks, reference); + ResolvedCallImpl resolvedCall = doResolveCall(trace, scope, call, expectedType, prioritizedTasks, reference); return resolvedCall == null ? null : resolvedCall.getResultingDescriptor(); } @Nullable - private ResolvedCall doResolveCall( + private ResolvedCallImpl doResolveCall( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull final Call call, @@ -210,7 +210,7 @@ public class CallResolver { OverloadResolutionResults resultsForFirstNonemptyCandidateSet = null; TracingStrategy tracing = new TracingStrategy() { @Override - public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCall resolvedCall) { + public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) { D descriptor = resolvedCall.getCandidateDescriptor(); // if (descriptor instanceof VariableAsFunctionDescriptor) { // VariableAsFunctionDescriptor variableAsFunctionDescriptor = (VariableAsFunctionDescriptor) descriptor; @@ -223,7 +223,7 @@ public class CallResolver { } @Override - public void recordAmbiguity(BindingTrace trace, Collection> candidates) { + public void recordAmbiguity(BindingTrace trace, Collection> candidates) { trace.record(AMBIGUOUS_REFERENCE_TARGET, reference, candidates); } @@ -272,12 +272,12 @@ public class CallResolver { } @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) { + public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) { trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(call.getCallNode(), descriptors)); } @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) { + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) { trace.report(NONE_APPLICABLE.on(reference, descriptors)); } @@ -352,7 +352,7 @@ public class CallResolver { @NotNull private OverloadResolutionResults performResolution(@NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull JetType expectedType, @NotNull ResolutionTask task, @NotNull TracingStrategy tracing) { - for (ResolvedCall candidateCall : task.getCandidates()) { + for (ResolvedCallImpl candidateCall : task.getCandidates()) { D candidate = candidateCall.getCandidateDescriptor(); TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); candidateCall.setTrace(temporaryTrace); @@ -483,9 +483,9 @@ public class CallResolver { recordAutoCastIfNecessary(candidateCall.getThisObject(), candidateCall.getTrace()); } - Set> successfulCandidates = Sets.newLinkedHashSet(); - Set> failedCandidates = Sets.newLinkedHashSet(); - for (ResolvedCall candidateCall : task.getCandidates()) { + Set> successfulCandidates = Sets.newLinkedHashSet(); + Set> failedCandidates = Sets.newLinkedHashSet(); + for (ResolvedCallImpl candidateCall : task.getCandidates()) { ResolutionStatus status = candidateCall.getStatus(); if (status.isSuccess()) { successfulCandidates.add(candidateCall); @@ -555,7 +555,7 @@ public class CallResolver { // }; // } - private void replaceValueParametersWithSubstitutedOnes(ResolvedCall candidateCall, @NotNull D substitutedDescriptor) { + private void replaceValueParametersWithSubstitutedOnes(ResolvedCallImpl candidateCall, @NotNull D substitutedDescriptor) { Map parameterMap = Maps.newHashMap(); for (ValueParameterDescriptor valueParameterDescriptor : substitutedDescriptor.getValueParameters()) { parameterMap.put(valueParameterDescriptor.getOriginal(), valueParameterDescriptor); @@ -571,14 +571,14 @@ public class CallResolver { } } - private ResolutionStatus checkAllValueArguments(JetScope scope, TracingStrategy tracing, ResolutionTask task, ResolvedCall candidateCall) { + private ResolutionStatus checkAllValueArguments(JetScope scope, TracingStrategy tracing, ResolutionTask task, ResolvedCallImpl candidateCall) { ResolutionStatus result = checkValueArgumentTypes(scope, candidateCall); result = result.combine(checkReceiver(tracing, candidateCall, candidateCall.getResultingDescriptor().getReceiverParameter(), candidateCall.getReceiverArgument(), task)); result = result.combine(checkReceiver(tracing, candidateCall, candidateCall.getResultingDescriptor().getExpectedThisObject(), candidateCall.getThisObject(), task)); return result; } - private ResolutionStatus checkReceiver(TracingStrategy tracing, ResolvedCall candidateCall, ReceiverDescriptor receiverParameter, ReceiverDescriptor receiverArgument, ResolutionTask task) { + private ResolutionStatus checkReceiver(TracingStrategy tracing, ResolvedCallImpl candidateCall, ReceiverDescriptor receiverParameter, ReceiverDescriptor receiverArgument, ResolutionTask task) { ResolutionStatus result = SUCCESS; if (receiverParameter.exists() && receiverArgument.exists()) { ASTNode callOperationNode = task.getCall().getCallOperationNode(); @@ -606,7 +606,7 @@ public class CallResolver { return result; } - private ResolutionStatus checkValueArgumentTypes(JetScope scope, ResolvedCall candidateCall) { + private ResolutionStatus checkValueArgumentTypes(JetScope scope, ResolvedCallImpl candidateCall) { ResolutionStatus result = SUCCESS; for (Map.Entry entry : candidateCall.getValueArguments().entrySet()) { ValueParameterDescriptor parameterDescriptor = entry.getKey(); @@ -653,16 +653,16 @@ public class CallResolver { private OverloadResolutionResults computeResultAndReportErrors( BindingTrace trace, TracingStrategy tracing, - Set> successfulCandidates, - Set> failedCandidates) { + Set> successfulCandidates, + Set> failedCandidates) { // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific if (successfulCandidates.size() > 0) { return chooseAndReportMaximallySpecific(trace, tracing, successfulCandidates); } else if (!failedCandidates.isEmpty()) { if (failedCandidates.size() != 1) { - Set> weakErrors = Sets.newLinkedHashSet(); - for (ResolvedCall candidate : failedCandidates) { + Set> weakErrors = Sets.newLinkedHashSet(); + for (ResolvedCallImpl candidate : failedCandidates) { if (candidate.getStatus().isWeakError()) { weakErrors.add(candidate); } @@ -676,7 +676,7 @@ public class CallResolver { return OverloadResolutionResults.manyFailedCandidates(results.getResults()); } - Set> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE); + Set> noOverrides = OverridingUtil.filterOverrides(failedCandidates, MAP_TO_CANDIDATE); if (noOverrides.size() != 1) { // tracing.reportOverallResolutionError(trace, "None of the following functions can be called with the arguments supplied: " // + makeErrorMessageForMultipleDescriptors(noOverrides)); @@ -686,7 +686,7 @@ public class CallResolver { } failedCandidates = noOverrides; } - ResolvedCall failed = failedCandidates.iterator().next(); + ResolvedCallImpl failed = failedCandidates.iterator().next(); failed.getTrace().commit(); return OverloadResolutionResults.singleFailedCandidate(failed); } @@ -696,12 +696,12 @@ public class CallResolver { } } - private OverloadResolutionResults chooseAndReportMaximallySpecific(BindingTrace trace, TracingStrategy tracing, Set> candidates) { + private OverloadResolutionResults chooseAndReportMaximallySpecific(BindingTrace trace, TracingStrategy tracing, Set> candidates) { if (candidates.size() != 1) { - Set> cleanCandidates = Sets.newLinkedHashSet(candidates); + Set> cleanCandidates = Sets.newLinkedHashSet(candidates); boolean allClean = true; - for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { - ResolvedCall candidate = iterator.next(); + for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { + ResolvedCallImpl candidate = iterator.next(); if (candidate.isDirty()) { iterator.remove(); allClean = false; @@ -711,17 +711,17 @@ public class CallResolver { if (cleanCandidates.isEmpty()) { cleanCandidates = candidates; } - ResolvedCall maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false); + ResolvedCallImpl maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false); if (maximallySpecific != null) { return OverloadResolutionResults.success(maximallySpecific); } - ResolvedCall maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true); + ResolvedCallImpl maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true); if (maximallySpecificGenericsDiscriminated != null) { return OverloadResolutionResults.success(maximallySpecificGenericsDiscriminated); } - Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); + Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); if (allClean) { // tracing.reportOverallResolutionError(trace, "Overload resolution ambiguity: " // + makeErrorMessageForMultipleDescriptors(noOverrides)); @@ -733,7 +733,7 @@ public class CallResolver { return OverloadResolutionResults.ambiguity(noOverrides); } else { - ResolvedCall result = candidates.iterator().next(); + ResolvedCallImpl result = candidates.iterator().next(); TemporaryBindingTrace temporaryTrace = result.getTrace(); temporaryTrace.commit(); @@ -762,24 +762,24 @@ public class CallResolver { @NotNull public OverloadResolutionResults resolveExactSignature(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { - List> result = findCandidatesByExactSignature(scope, receiver, name, parameterTypes); + List> result = findCandidatesByExactSignature(scope, receiver, name, parameterTypes); BindingTraceContext trace = new BindingTraceContext(); TemporaryBindingTrace temporaryBindingTrace = TemporaryBindingTrace.create(trace); - Set> candidates = Sets.newLinkedHashSet(); - for (ResolvedCall call : result) { + Set> candidates = Sets.newLinkedHashSet(); + for (ResolvedCallImpl call : result) { call.setTrace(temporaryBindingTrace); candidates.add(call); } - return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, candidates, Collections.>emptySet()); + return computeResultAndReportErrors(trace, TracingStrategy.EMPTY, candidates, Collections.>emptySet()); } - private List> findCandidatesByExactSignature(JetScope scope, ReceiverDescriptor receiver, String name, List parameterTypes) { - List> result = Lists.newArrayList(); + private List> findCandidatesByExactSignature(JetScope scope, ReceiverDescriptor receiver, String name, List parameterTypes) { + List> result = Lists.newArrayList(); if (receiver.exists()) { - Collection> extensionFunctionDescriptors = ResolvedCall.convertCollection(scope.getFunctions(name)); - List> nonlocal = Lists.newArrayList(); - List> local = Lists.newArrayList(); + Collection> extensionFunctionDescriptors = ResolvedCallImpl.convertCollection(scope.getFunctions(name)); + List> nonlocal = Lists.newArrayList(); + List> local = Lists.newArrayList(); TaskPrioritizer.splitLexicallyLocalDescriptors(extensionFunctionDescriptors, scope.getContainingDeclaration(), local, nonlocal); @@ -787,7 +787,7 @@ public class CallResolver { return result; } - Collection> functionDescriptors = ResolvedCall.convertCollection(receiver.getType().getMemberScope().getFunctions(name)); + Collection> functionDescriptors = ResolvedCallImpl.convertCollection(receiver.getType().getMemberScope().getFunctions(name)); if (lookupExactSignature(functionDescriptors, parameterTypes, result)) { return result; @@ -796,14 +796,14 @@ public class CallResolver { return result; } else { - lookupExactSignature(ResolvedCall.convertCollection(scope.getFunctions(name)), parameterTypes, result); + lookupExactSignature(ResolvedCallImpl.convertCollection(scope.getFunctions(name)), parameterTypes, result); return result; } } - private boolean lookupExactSignature(Collection> candidates, List parameterTypes, List> result) { + private boolean lookupExactSignature(Collection> candidates, List parameterTypes, List> result) { boolean found = false; - for (ResolvedCall resolvedCall : candidates) { + for (ResolvedCallImpl resolvedCall : candidates) { FunctionDescriptor functionDescriptor = resolvedCall.getResultingDescriptor(); if (functionDescriptor.getReceiverParameter().exists()) continue; if (!functionDescriptor.getTypeParameters().isEmpty()) continue; @@ -814,9 +814,9 @@ public class CallResolver { return found; } - private boolean findExtensionFunctions(Collection> candidates, ReceiverDescriptor receiver, List parameterTypes, List> result) { + private boolean findExtensionFunctions(Collection> candidates, ReceiverDescriptor receiver, List parameterTypes, List> result) { boolean found = false; - for (ResolvedCall resolvedCall : candidates) { + for (ResolvedCallImpl resolvedCall : candidates) { FunctionDescriptor functionDescriptor = resolvedCall.getResultingDescriptor(); ReceiverDescriptor functionReceiver = functionDescriptor.getReceiverParameter(); if (!functionReceiver.exists()) continue; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java index e93b7a0a2db..dfe84f5f26c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResults.java @@ -29,40 +29,40 @@ public class OverloadResolutionResults { } - public static OverloadResolutionResults success(@NotNull ResolvedCall descriptor) { + public static OverloadResolutionResults success(@NotNull ResolvedCallImpl descriptor) { return new OverloadResolutionResults(Code.SUCCESS, Collections.singleton(descriptor)); } public static OverloadResolutionResults nameNotFound() { - return new OverloadResolutionResults(Code.NAME_NOT_FOUND, Collections.>emptyList()); + return new OverloadResolutionResults(Code.NAME_NOT_FOUND, Collections.>emptyList()); } - public static OverloadResolutionResults singleFailedCandidate(ResolvedCall candidate) { + public static OverloadResolutionResults singleFailedCandidate(ResolvedCallImpl candidate) { return new OverloadResolutionResults(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate)); } - public static OverloadResolutionResults manyFailedCandidates(Collection> failedCandidates) { + public static OverloadResolutionResults manyFailedCandidates(Collection> failedCandidates) { return new OverloadResolutionResults(Code.MANY_FAILED_CANDIDATES, failedCandidates); } - public static OverloadResolutionResults ambiguity(Collection> descriptors) { + public static OverloadResolutionResults ambiguity(Collection> descriptors) { return new OverloadResolutionResults(Code.AMBIGUITY, descriptors); } - private final Collection> results; + private final Collection> results; private final Code resultCode; - private OverloadResolutionResults(@NotNull Code resultCode, @NotNull Collection> results) { + private OverloadResolutionResults(@NotNull Code resultCode, @NotNull Collection> results) { this.results = results; this.resultCode = resultCode; } @NotNull - public Collection> getResults() { + public Collection> getResults() { return results; } @NotNull - public ResolvedCall getResult() { + public ResolvedCallImpl getResult() { assert singleDescriptor(); return results.iterator().next(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java index dc12c9ab9bc..4758dfd54af 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java @@ -28,23 +28,23 @@ public class OverloadingConflictResolver { } @Nullable - public ResolvedCall findMaximallySpecific(Set> candidates, boolean discriminateGenericDescriptors) { - // Different autocasts may lead to the same candidate descriptor wrapped into different ResolvedCall objects - Set> maximallySpecific = new THashSet>(new TObjectHashingStrategy>() { + public ResolvedCallImpl findMaximallySpecific(Set> candidates, boolean discriminateGenericDescriptors) { + // Different autocasts may lead to the same candidate descriptor wrapped into different ResolvedCallImpl objects + Set> maximallySpecific = new THashSet>(new TObjectHashingStrategy>() { @Override - public boolean equals(ResolvedCall o1, ResolvedCall o2) { + public boolean equals(ResolvedCallImpl o1, ResolvedCallImpl o2) { return o1 == null ? o2 == null : o1.getResultingDescriptor().equals(o2.getResultingDescriptor()); } @Override - public int computeHashCode(ResolvedCall object) { + public int computeHashCode(ResolvedCallImpl object) { return object == null ? 0 : object.getResultingDescriptor().hashCode(); } }); meLoop: - for (ResolvedCall candidateCall : candidates) { + for (ResolvedCallImpl candidateCall : candidates) { D me = candidateCall.getResultingDescriptor(); - for (ResolvedCall otherCall : candidates) { + for (ResolvedCallImpl otherCall : candidates) { D other = otherCall.getResultingDescriptor(); if (other == me) continue; if (!moreSpecific(me, other, discriminateGenericDescriptors) || moreSpecific(other, me, discriminateGenericDescriptors)) { @@ -54,7 +54,7 @@ public class OverloadingConflictResolver { maximallySpecific.add(candidateCall); } if (maximallySpecific.size() == 1) { - ResolvedCall result = maximallySpecific.iterator().next(); + ResolvedCallImpl result = maximallySpecific.iterator().next(); result.getTrace().commit(); return result; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java index 1fbce7ba838..ecde91cc4ed 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java @@ -13,13 +13,13 @@ import java.util.Collection; */ /*package*/ class ResolutionTask { private final Call call; - private final Collection> candidates; + private final Collection> candidates; private final DataFlowInfo dataFlowInfo; private DescriptorCheckStrategy checkingStrategy; public ResolutionTask( - @NotNull Collection> candidates, + @NotNull Collection> candidates, @NotNull Call call, @NotNull DataFlowInfo dataFlowInfo ) { @@ -34,7 +34,7 @@ import java.util.Collection; } @NotNull - public Collection> getCandidates() { + public Collection> getCandidates() { return candidates; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCall.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java similarity index 77% rename from compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCall.java rename to compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java index c5a870da312..d1eb79faa4a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCall.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallImpl.java @@ -21,30 +21,30 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor /** * @author abreslav */ -public class ResolvedCall { +public class ResolvedCallImpl implements ResolvedCallInterface { - public static final Function, CallableDescriptor> MAP_TO_CANDIDATE = new Function, CallableDescriptor>() { + public static final Function, CallableDescriptor> MAP_TO_CANDIDATE = new Function, CallableDescriptor>() { @Override - public CallableDescriptor fun(ResolvedCall resolvedCall) { + public CallableDescriptor fun(ResolvedCallImpl resolvedCall) { return resolvedCall.getCandidateDescriptor(); } }; - public static final Function, CallableDescriptor> MAP_TO_RESULT = new Function, CallableDescriptor>() { + public static final Function, CallableDescriptor> MAP_TO_RESULT = new Function, CallableDescriptor>() { @Override - public CallableDescriptor fun(ResolvedCall resolvedCall) { + public CallableDescriptor fun(ResolvedCallImpl resolvedCall) { return resolvedCall.getResultingDescriptor(); } }; @NotNull - public static ResolvedCall create(@NotNull D descriptor) { - return new ResolvedCall(descriptor); + public static ResolvedCallImpl create(@NotNull D descriptor) { + return new ResolvedCallImpl(descriptor); } @NotNull - public static List> convertCollection(@NotNull Collection descriptors) { - List> result = Lists.newArrayList(); + public static List> convertCollection(@NotNull Collection descriptors) { + List> result = Lists.newArrayList(); for (D descriptor : descriptors) { result.add(create(descriptor)); } @@ -63,10 +63,11 @@ public class ResolvedCall { private TemporaryBindingTrace trace; private ResolutionStatus status = UNKNOWN_STATUS; - private ResolvedCall(@NotNull D candidateDescriptor) { + private ResolvedCallImpl(@NotNull D candidateDescriptor) { this.candidateDescriptor = candidateDescriptor; } + @Override @NotNull public ResolutionStatus getStatus() { return status; @@ -85,17 +86,19 @@ public class ResolvedCall { this.trace = trace; } + @Override @NotNull public D getCandidateDescriptor() { return candidateDescriptor; } + @Override @NotNull public D getResultingDescriptor() { return resultingDescriptor == null ? candidateDescriptor : resultingDescriptor; } - public ResolvedCall setResultingDescriptor(@NotNull D resultingDescriptor) { + public ResolvedCallImpl setResultingDescriptor(@NotNull D resultingDescriptor) { this.resultingDescriptor = resultingDescriptor; return this; } @@ -115,6 +118,7 @@ public class ResolvedCall { autoCasts.put(parameter, target); } + @Override @NotNull public ReceiverDescriptor getReceiverArgument() { return receiverArgument; @@ -124,6 +128,7 @@ public class ResolvedCall { this.receiverArgument = receiverParameter; } + @Override @NotNull public ReceiverDescriptor getThisObject() { return thisObject; @@ -133,6 +138,7 @@ public class ResolvedCall { this.thisObject = thisObject; } + @Override @NotNull public Map getValueArguments() { return valueArguments; @@ -146,6 +152,7 @@ public class ResolvedCall { return someArgumentHasNoType; } + @Override public Map getTypeArguments() { return typeArguments; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallInterface.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallInterface.java new file mode 100644 index 00000000000..4e250bab4b4 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolvedCallInterface.java @@ -0,0 +1,35 @@ +package org.jetbrains.jet.lang.resolve.calls; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.types.JetType; + +import java.util.Map; + +/** + * @author abreslav + */ +public interface ResolvedCallInterface { + @NotNull + ResolutionStatus getStatus(); + + @NotNull + D getCandidateDescriptor(); + + @NotNull + D getResultingDescriptor(); + + @NotNull + ReceiverDescriptor getReceiverArgument(); + + @NotNull + ReceiverDescriptor getThisObject(); + + @NotNull + Map getValueArguments(); + + Map getTypeArguments(); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java index ad1b4c55512..5bfc0947a8e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java @@ -29,9 +29,9 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor /*package*/ abstract class TaskPrioritizer { public static void splitLexicallyLocalDescriptors( - Collection> allDescriptors, DeclarationDescriptor containerOfTheCurrentLocality, Collection> local, Collection> nonlocal) { + Collection> allDescriptors, DeclarationDescriptor containerOfTheCurrentLocality, Collection> local, Collection> nonlocal) { - for (ResolvedCall resolvedCall : allDescriptors) { + for (ResolvedCallImpl resolvedCall : allDescriptors) { if (isLocal(containerOfTheCurrentLocality, resolvedCall.getCandidateDescriptor())) { local.add(resolvedCall); } @@ -96,13 +96,13 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor if (receiver.exists()) { List variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver); - Collection> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, getExtensionsByName(scope, name)); - List> nonlocals = Lists.newArrayList(); - List> locals = Lists.newArrayList(); + Collection> extensionFunctions = convertWithImpliedThis(scope, variantsForExplicitReceiver, getExtensionsByName(scope, name)); + List> nonlocals = Lists.newArrayList(); + List> locals = Lists.newArrayList(); //noinspection unchecked,RedundantTypeArguments TaskPrioritizer.splitLexicallyLocalDescriptors(extensionFunctions, scope.getContainingDeclaration(), locals, nonlocals); - Collection> members = Lists.newArrayList(); + Collection> members = Lists.newArrayList(); for (ReceiverDescriptor variant : variantsForExplicitReceiver) { Collection membersForThisVariant = getMembersByName(variant.getType(), name); convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), Collections.singletonList(NO_RECEIVER), members); @@ -120,10 +120,10 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor addTask(result, call, nonlocals, dataFlowInfo); } else { - Collection> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), getNonExtensionsByName(scope, name)); + Collection> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), getNonExtensionsByName(scope, name)); - List> nonlocals = Lists.newArrayList(); - List> locals = Lists.newArrayList(); + List> nonlocals = Lists.newArrayList(); + List> locals = Lists.newArrayList(); //noinspection unchecked,RedundantTypeArguments TaskPrioritizer.splitLexicallyLocalDescriptors(functions, scope.getContainingDeclaration(), locals, nonlocals); @@ -137,18 +137,18 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor } } - private Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters) { - Collection> result = Lists.newArrayList(); + private Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters) { + Collection> result = Lists.newArrayList(); convertWithReceivers(descriptors, thisObjects, receiverParameters, result); return result; } - private void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, Collection> result) { -// Collection> result = Lists.newArrayList(); + private void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, Collection> result) { +// Collection> result = Lists.newArrayList(); for (ReceiverDescriptor thisObject : thisObjects) { for (ReceiverDescriptor receiverParameter : receiverParameters) { for (D extension : descriptors) { - ResolvedCall resolvedCall = ResolvedCall.create(extension); + ResolvedCallImpl resolvedCall = ResolvedCallImpl.create(extension); resolvedCall.setThisObject(thisObject); resolvedCall.setReceiverArgument(receiverParameter); result.add(resolvedCall); @@ -158,11 +158,11 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor // return result; } - public static Collection> convertWithImpliedThis(JetScope scope, Iterable receiverParameters, Collection descriptors) { - Collection> result = Lists.newArrayList(); + public static Collection> convertWithImpliedThis(JetScope scope, Iterable receiverParameters, Collection descriptors) { + Collection> result = Lists.newArrayList(); for (ReceiverDescriptor receiverParameter : receiverParameters) { for (D extension : descriptors) { - ResolvedCall resolvedCall = ResolvedCall.create(extension); + ResolvedCallImpl resolvedCall = ResolvedCallImpl.create(extension); resolvedCall.setReceiverArgument(receiverParameter); if (setImpliedThis(scope, resolvedCall)) { result.add(resolvedCall); @@ -172,7 +172,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor return result; } - private static boolean setImpliedThis(@NotNull JetScope scope, ResolvedCall resolvedCall) { + private static boolean setImpliedThis(@NotNull JetScope scope, ResolvedCallImpl resolvedCall) { ReceiverDescriptor expectedThisObject = resolvedCall.getCandidateDescriptor().getExpectedThisObject(); if (!expectedThisObject.exists()) return true; List receivers = Lists.newArrayList(); @@ -187,7 +187,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor return false; } - private void addTask(@NotNull List> result, @NotNull Call call, @NotNull Collection> candidates, @NotNull DataFlowInfo dataFlowInfo) { + private void addTask(@NotNull List> result, @NotNull Call call, @NotNull Collection> candidates, @NotNull DataFlowInfo dataFlowInfo) { if (candidates.isEmpty()) return; result.add(new ResolutionTask(candidates, call, dataFlowInfo)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java index a7e7096b2de..6284ccb5b0d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TracingStrategy.java @@ -16,13 +16,13 @@ import java.util.Set; /*package*/ interface TracingStrategy { TracingStrategy EMPTY = new TracingStrategy() { @Override - public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCall resolvedCall) {} + public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) {} @Override public void unresolvedReference(@NotNull BindingTrace trace) {} @Override - public void recordAmbiguity(BindingTrace trace, Collection> candidates) {} + public void recordAmbiguity(BindingTrace trace, Collection> candidates) {} @Override public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver) {} @@ -40,10 +40,10 @@ import java.util.Set; public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) {} @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} + public void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors) {} @Override public void instantiationOfAbstractClass(@NotNull BindingTrace trace) {} @@ -58,11 +58,11 @@ import java.util.Set; public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type) {} }; - void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCall resolvedCall); + void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall); void unresolvedReference(@NotNull BindingTrace trace); - void recordAmbiguity(BindingTrace trace, Collection> candidates); + void recordAmbiguity(BindingTrace trace, Collection> candidates); void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver); @@ -74,9 +74,9 @@ import java.util.Set; void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount); - void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors); + void ambiguity(@NotNull BindingTrace trace, @NotNull Set> descriptors); - void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors); + void noneApplicable(@NotNull BindingTrace trace, @NotNull Set> descriptors); void instantiationOfAbstractClass(@NotNull BindingTrace trace); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java index 8338f750b11..402b3f1aa62 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java @@ -23,7 +23,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; public static boolean mapValueArgumentsToParameters( @NotNull ResolutionTask task, @NotNull TracingStrategy tracing, - @NotNull ResolvedCall candidateCall + @NotNull ResolvedCallImpl candidateCall ) { TemporaryBindingTrace temporaryTrace = candidateCall.getTrace(); @@ -181,7 +181,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; return error; } - private static void put(ResolvedCall candidateCall, ValueParameterDescriptor valueParameterDescriptor, ValueArgument valueArgument, Map varargs) { + private static void put(ResolvedCallImpl candidateCall, ValueParameterDescriptor valueParameterDescriptor, ValueArgument valueArgument, Map varargs) { if (valueParameterDescriptor.isVararg()) { VarargValueArgument vararg = varargs.get(valueParameterDescriptor); if (vararg == null) { diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java b/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java index bade37c7e0b..d749f54e81b 100644 --- a/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java +++ b/idea/src/org/jetbrains/jet/plugin/annotations/DebugInfoAnnotator.java @@ -15,7 +15,7 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnostic; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.plugin.AnalyzerFacade; @@ -92,7 +92,7 @@ public class DebugInfoAnnotator implements Annotator { target = labelTarget.getText(); } else { - Collection> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, expression); + Collection> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, expression); if (declarationDescriptors != null) { target = "[" + declarationDescriptors.size() + " descriptors]"; } diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java b/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java index 9916a18468f..76cdd4a0a42 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java +++ b/idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java @@ -11,7 +11,7 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; import org.jetbrains.jet.plugin.AnalyzerFacade; import java.util.Collection; @@ -81,7 +81,7 @@ public abstract class JetPsiReference implements PsiPolyVariantReference { if (psiElement != null) { return psiElement; } - Collection> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression); + Collection> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression); if (declarationDescriptors != null) return null; return file; } @@ -89,11 +89,11 @@ public abstract class JetPsiReference implements PsiPolyVariantReference { protected ResolveResult[] doMultiResolve() { JetFile file = (JetFile) getElement().getContainingFile(); BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file); - Collection> resolvedCalls = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression); + Collection> resolvedCalls = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression); if (resolvedCalls == null) return ResolveResult.EMPTY_ARRAY; ResolveResult[] results = new ResolveResult[resolvedCalls.size()]; int i = 0; - for (ResolvedCall resolvedCall : resolvedCalls) { + for (ResolvedCallImpl resolvedCall : resolvedCalls) { PsiElement element = bindingContext.get(DESCRIPTOR_TO_DECLARATION, resolvedCall.getResultingDescriptor()); if (element != null) { results[i] = new PsiElementResolveResult(element, true); diff --git a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java index f921ed4ba05..2d1afcd62c7 100644 --- a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -17,9 +17,9 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.calls.CallResolver; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.parsing.JetParsingTest; @@ -114,7 +114,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { CallResolver callResolver = new CallResolver(JetSemanticServices.createSemanticServices(getProject()), DataFlowInfo.EMPTY); OverloadResolutionResults functions = callResolver.resolveExactSignature( classDescriptor.getMemberScope(typeArguments), ReceiverDescriptor.NO_RECEIVER, name, parameterTypeList); - for (ResolvedCall resolvedCall : functions.getResults()) { + for (ResolvedCallImpl resolvedCall : functions.getResults()) { List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i);