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 176524e2c9a..4f753b068a0 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 @@ -372,10 +372,10 @@ public class CallResolver { }; TemporaryBindingTrace traceForFirstNonemptyCandidateSet = null; - OverloadResolutionResults resultsForFirstNonemptyCandidateSet = null; + OverloadResolutionResultsImpl resultsForFirstNonemptyCandidateSet = null; for (ResolutionTask task : prioritizedTasks) { TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); - OverloadResolutionResults results = performResolution(temporaryTrace, scope, expectedType, task, tracing); + OverloadResolutionResultsImpl results = performResolution(temporaryTrace, scope, expectedType, task, tracing); if (results.isSuccess()) { temporaryTrace.commit(); @@ -407,7 +407,7 @@ public class CallResolver { ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @NotNull - private OverloadResolutionResults performResolution( + private OverloadResolutionResultsImpl performResolution( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull JetType expectedType, @NotNull ResolutionTask task, @NotNull TracingStrategy tracing @@ -593,7 +593,7 @@ public class CallResolver { } } - OverloadResolutionResults results = computeResultAndReportErrors(trace, tracing, successfulCandidates, failedCandidates); + OverloadResolutionResultsImpl results = computeResultAndReportErrors(trace, tracing, successfulCandidates, failedCandidates); if (!results.singleDescriptor()) { checkTypesWithNoCallee(trace, scope, task.getCall()); } @@ -740,7 +740,7 @@ public class CallResolver { } @NotNull - private OverloadResolutionResults computeResultAndReportErrors( + private OverloadResolutionResultsImpl computeResultAndReportErrors( BindingTrace trace, TracingStrategy tracing, Set> successfulCandidates, @@ -748,7 +748,7 @@ public class CallResolver { // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific if (successfulCandidates.size() > 0) { - OverloadResolutionResults results = chooseAndReportMaximallySpecific(successfulCandidates, true); + OverloadResolutionResultsImpl results = chooseAndReportMaximallySpecific(successfulCandidates, true); if (results.isAmbiguity()) { // 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 @@ -772,15 +772,15 @@ public class CallResolver { } } if (!thisLevel.isEmpty()) { - OverloadResolutionResults results = chooseAndReportMaximallySpecific(thisLevel, false); + OverloadResolutionResultsImpl results = chooseAndReportMaximallySpecific(thisLevel, false); if (results.isSuccess()) { results.getResult().getTrace().commit(); - return OverloadResolutionResults.singleFailedCandidate(results.getResult()); + return OverloadResolutionResultsImpl.singleFailedCandidate(results.getResult()); } tracing.noneApplicable(trace, results.getResults()); tracing.recordAmbiguity(trace, results.getResults()); - return OverloadResolutionResults.manyFailedCandidates(results.getResults()); + return OverloadResolutionResultsImpl.manyFailedCandidates(results.getResults()); } } assert false : "Should not be reachable, cause every status must belong to some level"; @@ -789,17 +789,17 @@ public class CallResolver { if (noOverrides.size() != 1) { tracing.noneApplicable(trace, noOverrides); tracing.recordAmbiguity(trace, noOverrides); - return OverloadResolutionResults.manyFailedCandidates(noOverrides); + return OverloadResolutionResultsImpl.manyFailedCandidates(noOverrides); } failedCandidates = noOverrides; } ResolvedCallImpl failed = failedCandidates.iterator().next(); failed.getTrace().commit(); - return OverloadResolutionResults.singleFailedCandidate(failed); + return OverloadResolutionResultsImpl.singleFailedCandidate(failed); } else { tracing.unresolvedReference(trace); - return OverloadResolutionResults.nameNotFound(); + return OverloadResolutionResultsImpl.nameNotFound(); } } @@ -810,7 +810,7 @@ public class CallResolver { return true; } - private OverloadResolutionResults chooseAndReportMaximallySpecific(Set> candidates, boolean discriminateGenerics) { + private OverloadResolutionResultsImpl chooseAndReportMaximallySpecific(Set> candidates, boolean discriminateGenerics) { if (candidates.size() != 1) { Set> cleanCandidates = Sets.newLinkedHashSet(candidates); for (Iterator> iterator = cleanCandidates.iterator(); iterator.hasNext(); ) { @@ -825,26 +825,26 @@ public class CallResolver { } ResolvedCallImpl maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, false); if (maximallySpecific != null) { - return OverloadResolutionResults.success(maximallySpecific); + return OverloadResolutionResultsImpl.success(maximallySpecific); } if (discriminateGenerics) { ResolvedCallImpl maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, true); if (maximallySpecificGenericsDiscriminated != null) { - return OverloadResolutionResults.success(maximallySpecificGenericsDiscriminated); + return OverloadResolutionResultsImpl.success(maximallySpecificGenericsDiscriminated); } } Set> noOverrides = OverridingUtil.filterOverrides(candidates, MAP_TO_RESULT); - return OverloadResolutionResults.ambiguity(noOverrides); + return OverloadResolutionResultsImpl.ambiguity(noOverrides); } else { ResolvedCallImpl result = candidates.iterator().next(); TemporaryBindingTrace temporaryTrace = result.getTrace(); temporaryTrace.commit(); - return OverloadResolutionResults.success(result); + return OverloadResolutionResultsImpl.success(result); } } @@ -868,7 +868,7 @@ public class CallResolver { } @NotNull - public OverloadResolutionResults resolveExactSignature(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { + public OverloadResolutionResultsImpl resolveExactSignature(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { List> result = findCandidatesByExactSignature(scope, receiver, name, parameterTypes); BindingTraceContext trace = new BindingTraceContext(); 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 dfe84f5f26c..9525accd886 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 @@ -4,13 +4,12 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import java.util.Collection; -import java.util.Collections; /** -* @author abreslav -*/ -public class OverloadResolutionResults { - public enum Code { + * @author abreslav + */ +public interface OverloadResolutionResults { + enum Code { SUCCESS(true), NAME_NOT_FOUND(false), SINGLE_CANDIDATE_ARGUMENT_MISMATCH(false), @@ -26,69 +25,22 @@ public class OverloadResolutionResults { boolean isSuccess() { return success; } - - } - - 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()); - } - - public static OverloadResolutionResults singleFailedCandidate(ResolvedCallImpl candidate) { - return new OverloadResolutionResults(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate)); - } - public static OverloadResolutionResults manyFailedCandidates(Collection> failedCandidates) { - return new OverloadResolutionResults(Code.MANY_FAILED_CANDIDATES, failedCandidates); - } - - public static OverloadResolutionResults ambiguity(Collection> descriptors) { - return new OverloadResolutionResults(Code.AMBIGUITY, descriptors); - } - - private final Collection> results; - private final Code resultCode; - - private OverloadResolutionResults(@NotNull Code resultCode, @NotNull Collection> results) { - this.results = results; - this.resultCode = resultCode; } @NotNull - public Collection> getResults() { - return results; - } + Collection> getResults(); @NotNull - public ResolvedCallImpl getResult() { - assert singleDescriptor(); - return results.iterator().next(); - } + ResolvedCall getResult(); @NotNull - public Code getResultCode() { - return resultCode; - } + Code getResultCode(); - public boolean isSuccess() { - return resultCode.isSuccess(); - } + boolean isSuccess(); - public boolean singleDescriptor() { - return isSuccess() || resultCode == Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH; - } + boolean singleDescriptor(); - public boolean isNothing() { - return resultCode == Code.NAME_NOT_FOUND; - } + boolean isNothing(); - public boolean isAmbiguity() { - return resultCode == Code.AMBIGUITY; - } -// -// public OverloadResolutionResults newContents(@NotNull Collection functionDescriptors) { -// return new OverloadResolutionResults(resultCode, functionDescriptors); -// } + boolean isAmbiguity(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java new file mode 100644 index 00000000000..577c365b694 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java @@ -0,0 +1,83 @@ +package org.jetbrains.jet.lang.resolve.calls; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; + +import java.util.Collection; +import java.util.Collections; + +/** +* @author abreslav +*/ +public class OverloadResolutionResultsImpl implements OverloadResolutionResults { + + public static OverloadResolutionResultsImpl success(@NotNull ResolvedCallImpl descriptor) { + return new OverloadResolutionResultsImpl(Code.SUCCESS, Collections.singleton(descriptor)); + } + + public static OverloadResolutionResultsImpl nameNotFound() { + return new OverloadResolutionResultsImpl(Code.NAME_NOT_FOUND, Collections.>emptyList()); + } + + public static OverloadResolutionResultsImpl singleFailedCandidate(ResolvedCallImpl candidate) { + return new OverloadResolutionResultsImpl(Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH, Collections.singleton(candidate)); + } + public static OverloadResolutionResultsImpl manyFailedCandidates(Collection> failedCandidates) { + return new OverloadResolutionResultsImpl(Code.MANY_FAILED_CANDIDATES, failedCandidates); + } + + public static OverloadResolutionResultsImpl ambiguity(Collection> descriptors) { + return new OverloadResolutionResultsImpl(Code.AMBIGUITY, descriptors); + } + + private final Collection> results; + private final Code resultCode; + + private OverloadResolutionResultsImpl(@NotNull Code resultCode, @NotNull Collection> results) { + this.results = results; + this.resultCode = resultCode; + } + + @Override + @NotNull + public Collection> getResults() { + return results; + } + + @Override + @NotNull + public ResolvedCallImpl getResult() { + assert singleDescriptor(); + return results.iterator().next(); + } + + @Override + @NotNull + public Code getResultCode() { + return resultCode; + } + + @Override + public boolean isSuccess() { + return resultCode.isSuccess(); + } + + @Override + public boolean singleDescriptor() { + return isSuccess() || resultCode == Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH; + } + + @Override + public boolean isNothing() { + return resultCode == Code.NAME_NOT_FOUND; + } + + @Override + public boolean isAmbiguity() { + return resultCode == Code.AMBIGUITY; + } +// +// public OverloadResolutionResultsImpl newContents(@NotNull Collection functionDescriptors) { +// return new OverloadResolutionResultsImpl(resultCode, functionDescriptors); +// } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index a2898afa2dd..8b58250041f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -15,7 +15,7 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.CallMaker; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; -import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; +import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResultsImpl; import org.jetbrains.jet.lang.resolve.constants.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; @@ -727,7 +727,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { String name = "equals"; if (right != null) { ExpressionReceiver receiver = ExpressionTypingUtils.safeGetExpressionReceiver(facade, left, context.replaceScope(context.scope)); - OverloadResolutionResults resolutionResults = context.resolveExactSignature( + OverloadResolutionResultsImpl resolutionResults = context.resolveExactSignature( receiver, "equals", Collections.singletonList(JetStandardClasses.getNullableAnyType())); if (resolutionResults.isSuccess()) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index f573e39e79a..961fb6fc9b3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -10,10 +10,8 @@ import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; -import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; +import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResultsImpl; import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.calls.TaskPrioritizers; -import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -237,7 +235,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { @Nullable private JetType checkIterableConvention(@NotNull ExpressionReceiver loopRange, ExpressionTypingContext context) { JetExpression loopRangeExpression = loopRange.getExpression(); - OverloadResolutionResults iteratorResolutionResults = context.resolveExactSignature(loopRange, "iterator", Collections.emptyList()); + OverloadResolutionResultsImpl iteratorResolutionResults = context.resolveExactSignature(loopRange, "iterator", Collections.emptyList()); if (iteratorResolutionResults.isSuccess()) { FunctionDescriptor iteratorFunction = iteratorResolutionResults.getResult().getResultingDescriptor(); @@ -259,7 +257,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { context.trace.record(LOOP_RANGE_HAS_NEXT, loopRange.getExpression(), hasNextFunctionSupported ? hasNextFunction : hasNextProperty); } - OverloadResolutionResults nextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "next", Collections.emptyList()); + OverloadResolutionResultsImpl nextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "next", Collections.emptyList()); if (nextResolutionResults.isAmbiguity()) { context.trace.report(NEXT_AMBIGUITY.on(loopRangeExpression)); } else if (nextResolutionResults.isNothing()) { @@ -288,7 +286,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { @Nullable private FunctionDescriptor checkHasNextFunctionSupport(@NotNull JetExpression loopRange, @NotNull JetType iteratorType, ExpressionTypingContext context) { - OverloadResolutionResults hasNextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "hasNext", Collections.emptyList()); + OverloadResolutionResultsImpl hasNextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "hasNext", Collections.emptyList()); if (hasNextResolutionResults.isAmbiguity()) { context.trace.report(HAS_NEXT_FUNCTION_AMBIGUITY.on(loopRange)); } else if (hasNextResolutionResults.isNothing()) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java index c27e9f998cd..3219126fdce 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingContext.java @@ -12,7 +12,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.calls.CallMaker; import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; +import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResultsImpl; import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver; @@ -196,7 +196,7 @@ import java.util.Map; } @NotNull - public OverloadResolutionResults resolveExactSignature(@NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { + public OverloadResolutionResultsImpl resolveExactSignature(@NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { return getCallResolver().resolveExactSignature(scope, receiver, name, parameterTypes); } } diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 0e772f2acd4..d8139d4ebd1 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -16,7 +16,7 @@ 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.OverloadResolutionResults; +import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResultsImpl; import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; @@ -113,7 +113,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { // JetTypeInferrer.Services typeInferrerServices = JetSemanticServices.createSemanticServices(getProject()).getTypeInferrerServices(new BindingTraceContext()); CallResolver callResolver = new CallResolver(JetSemanticServices.createSemanticServices(getProject()), DataFlowInfo.EMPTY); - OverloadResolutionResults functions = callResolver.resolveExactSignature( + OverloadResolutionResultsImpl functions = callResolver.resolveExactSignature( classDescriptor.getMemberScope(typeArguments), ReceiverDescriptor.NO_RECEIVER, name, parameterTypeList); for (ResolvedCallImpl resolvedCall : functions.getResults()) { List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters();