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 23126722df9..74f47e8508c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/AmbiguousDescriptorDiagnosticFactory.java @@ -1,8 +1,8 @@ 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.ResolvedCallImpl; +import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; 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 (ResolvedCallImpl call : argument) { + for (ResolvedCall 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/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java index f05397f66a5..779286f8b02 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java @@ -4,12 +4,14 @@ import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.JetSemanticServices; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.JetAnnotationEntry; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetModifierList; 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.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -52,8 +54,13 @@ public class AnnotationResolver { } public void resolveAnnotationStub(@NotNull JetScope scope, @NotNull JetAnnotationEntry entryElement, @NotNull AnnotationDescriptor descriptor) { - JetType jetType = callResolver.resolveCall(trace, scope, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, entryElement), NO_EXPECTED_TYPE); - descriptor.setAnnotationType(jetType == null ? ErrorUtils.createErrorType("Unresolved annotation type") : jetType); + OverloadResolutionResults results = callResolver.resolveCall(trace, scope, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, entryElement), NO_EXPECTED_TYPE); + if (results.isSuccess()) { + descriptor.setAnnotationType(results.getResultingDescriptor().getReturnType()); + } + else { + descriptor.setAnnotationType(ErrorUtils.createErrorType("Unresolved annotation type")); + } } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index a7559726cd6..171a69870b3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -3,7 +3,6 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.intellij.lang.ASTNode; -import com.intellij.openapi.util.Pair; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.containers.Queue; import org.jetbrains.annotations.NotNull; @@ -11,6 +10,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; 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.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -122,10 +122,11 @@ public class BodyResolver { JetTypeReference typeReference = call.getTypeReference(); if (typeReference != null) { if (descriptor.getUnsubstitutedPrimaryConstructor() != null) { - JetType supertype = new CallResolver(context.getSemanticServices(), DataFlowInfo.EMPTY).resolveCall( + OverloadResolutionResults results = new CallResolver(context.getSemanticServices(), DataFlowInfo.EMPTY).resolveCall( context.getTrace(), scopeForConstructor, CallMaker.makeCall(ReceiverDescriptor.NO_RECEIVER, null, call), NO_EXPECTED_TYPE); - if (supertype != null) { + if (results.isSuccess()) { + JetType supertype = results.getResultingDescriptor().getReturnType(); recordSupertype(typeReference, supertype); ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype); if (classDescriptor != null) { 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 4f753b068a0..989710ce480 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 @@ -6,7 +6,6 @@ import com.google.common.collect.Sets; import com.intellij.lang.ASTNode; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; @@ -29,9 +28,7 @@ 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.ResolvedCallImpl.MAP_TO_CANDIDATE; import static org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl.MAP_TO_RESULT; -import static org.jetbrains.jet.lang.resolve.calls.inference.ConstraintType.EXPECTED_TYPE; -import static org.jetbrains.jet.lang.resolve.calls.inference.ConstraintType.RECEIVER; -import static org.jetbrains.jet.lang.resolve.calls.inference.ConstraintType.VALUE_ARGUMENT; +import static org.jetbrains.jet.lang.resolve.calls.inference.ConstraintType.*; import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; @@ -51,8 +48,8 @@ public class CallResolver { this.dataFlowInfo = dataFlowInfo; } - @Nullable - public VariableDescriptor resolveSimpleProperty( + @NotNull + public OverloadResolutionResults resolveSimpleProperty( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull Call call, @@ -76,19 +73,18 @@ public class CallResolver { return resolveCallToDescriptor(trace, scope, call, expectedType, prioritizedTasks, nameExpression); } - @Nullable - public JetType resolveCall( + @NotNull + public OverloadResolutionResults resolveCall( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull Call call, @NotNull JetType expectedType ) { - FunctionDescriptor functionDescriptor = resolveSimpleCallToFunctionDescriptor(trace, scope, call, expectedType); - return functionDescriptor == null ? null : functionDescriptor.getReturnType(); + return resolveSimpleCallToFunctionDescriptor(trace, scope, call, expectedType); } - @Nullable - public ResolvedCall resolveCallWithGivenName( + @NotNull + public OverloadResolutionResults resolveCallWithGivenName( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull final Call call, @@ -100,8 +96,8 @@ public class CallResolver { return doResolveCall(trace, scope, call, expectedType, tasks, functionReference); } - @Nullable - private FunctionDescriptor resolveSimpleCallToFunctionDescriptor( + @NotNull + private OverloadResolutionResults resolveSimpleCallToFunctionDescriptor( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull final Call call, @@ -189,11 +185,11 @@ public class CallResolver { JetType calleeType = typingServices.safeGetType(scope, calleeExpression, NO_EXPECTED_TYPE); // We are actually expecting a function, but there seems to be no easy way of expressing this if (!JetStandardClasses.isFunctionType(calleeType)) { - checkTypesWithNoCallee(trace, scope, call); +// checkTypesWithNoCallee(trace, scope, call); if (!ErrorUtils.isErrorType(calleeType)) { trace.report(CALLEE_NOT_A_FUNCTION.on(calleeExpression, calleeType)); } - return null; + return checkArgumentTypesAndFail(trace, scope, call); } FunctionDescriptorImpl functionDescriptor = new ExpressionAsFunctionDescriptor(scope.getContainingDeclaration(), "[for expression " + calleeExpression.getText() + "]"); @@ -209,33 +205,32 @@ public class CallResolver { functionReference = new JetFakeReference(calleeExpression); } else { - checkTypesWithNoCallee(trace, scope, call); - return null; +// checkTypesWithNoCallee(trace, scope, call); + return checkArgumentTypesAndFail(trace, scope, call); } } return resolveCallToDescriptor(trace, scope, call, expectedType, prioritizedTasks, functionReference); } - private FunctionDescriptor checkArgumentTypesAndFail(BindingTrace trace, JetScope scope, Call call) { + private OverloadResolutionResults checkArgumentTypesAndFail(BindingTrace trace, JetScope scope, Call call) { checkTypesWithNoCallee(trace, scope, call); - return null; + return OverloadResolutionResultsImpl.nameNotFound(); } - @Nullable - private D resolveCallToDescriptor( + @NotNull + private OverloadResolutionResults resolveCallToDescriptor( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull final Call call, @NotNull JetType expectedType, @NotNull final List> prioritizedTasks, // high to low priority @NotNull final JetReferenceExpression reference) { - ResolvedCallImpl resolvedCall = doResolveCall(trace, scope, call, expectedType, prioritizedTasks, reference); - return resolvedCall == null ? null : resolvedCall.getResultingDescriptor(); + return doResolveCall(trace, scope, call, expectedType, prioritizedTasks, reference); } - @Nullable - private ResolvedCallImpl doResolveCall( + @NotNull + private OverloadResolutionResults doResolveCall( @NotNull BindingTrace trace, @NotNull JetScope scope, @NotNull final Call call, @@ -379,9 +374,9 @@ public class CallResolver { if (results.isSuccess()) { temporaryTrace.commit(); - debugInfo.set(ResolutionDebugInfo.RESULT, results.getResult()); + debugInfo.set(ResolutionDebugInfo.RESULT, results.getResultingCall()); - return results.getResult(); + return results; } if (traceForFirstNonemptyCandidateSet == null && !task.getCandidates().isEmpty()) { traceForFirstNonemptyCandidateSet = temporaryTrace; @@ -390,18 +385,16 @@ public class CallResolver { } if (traceForFirstNonemptyCandidateSet != null) { traceForFirstNonemptyCandidateSet.commit(); - if (resultsForFirstNonemptyCandidateSet.singleDescriptor()) { + if (resultsForFirstNonemptyCandidateSet.singleResult()) { - debugInfo.set(ResolutionDebugInfo.RESULT, resultsForFirstNonemptyCandidateSet.getResult()); - - return resultsForFirstNonemptyCandidateSet.getResult(); + debugInfo.set(ResolutionDebugInfo.RESULT, resultsForFirstNonemptyCandidateSet.getResultingCall()); } } else { trace.report(UNRESOLVED_REFERENCE.on(reference)); checkTypesWithNoCallee(trace, scope, call); } - return null; + return resultsForFirstNonemptyCandidateSet != null ? resultsForFirstNonemptyCandidateSet : OverloadResolutionResultsImpl.nameNotFound(); } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -594,7 +587,7 @@ public class CallResolver { } OverloadResolutionResultsImpl results = computeResultAndReportErrors(trace, tracing, successfulCandidates, failedCandidates); - if (!results.singleDescriptor()) { + if (!results.singleResult()) { checkTypesWithNoCallee(trace, scope, task.getCall()); } return results; @@ -752,10 +745,10 @@ public class CallResolver { 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 - if (allClean(results.getResults())) { - tracing.ambiguity(trace, results.getResults()); + if (allClean(results.getResultingCalls())) { + tracing.ambiguity(trace, results.getResultingCalls()); } - tracing.recordAmbiguity(trace, results.getResults()); + tracing.recordAmbiguity(trace, results.getResultingCalls()); } return results; } @@ -774,13 +767,13 @@ public class CallResolver { if (!thisLevel.isEmpty()) { OverloadResolutionResultsImpl results = chooseAndReportMaximallySpecific(thisLevel, false); if (results.isSuccess()) { - results.getResult().getTrace().commit(); - return OverloadResolutionResultsImpl.singleFailedCandidate(results.getResult()); + results.getResultingCall().getTrace().commit(); + return OverloadResolutionResultsImpl.singleFailedCandidate(results.getResultingCall()); } - tracing.noneApplicable(trace, results.getResults()); - tracing.recordAmbiguity(trace, results.getResults()); - return OverloadResolutionResultsImpl.manyFailedCandidates(results.getResults()); + tracing.noneApplicable(trace, results.getResultingCalls()); + tracing.recordAmbiguity(trace, results.getResultingCalls()); + return OverloadResolutionResultsImpl.manyFailedCandidates(results.getResultingCalls()); } } assert false : "Should not be reachable, cause every status must belong to some level"; @@ -848,7 +841,7 @@ public class CallResolver { } } - public void checkGenericBoundsInAFunctionCall(List jetTypeArguments, List typeArguments, CallableDescriptor functionDescriptor, BindingTrace trace) { + private void checkGenericBoundsInAFunctionCall(List jetTypeArguments, List typeArguments, CallableDescriptor functionDescriptor, BindingTrace trace) { Map context = Maps.newHashMap(); List typeParameters = functionDescriptor.getOriginal().getTypeParameters(); @@ -868,7 +861,7 @@ public class CallResolver { } @NotNull - public OverloadResolutionResultsImpl resolveExactSignature(@NotNull JetScope scope, @NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { + public OverloadResolutionResults 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 9525accd886..83cd6084ccd 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 @@ -28,17 +28,20 @@ public interface OverloadResolutionResults { } @NotNull - Collection> getResults(); + Collection> getResultingCalls(); @NotNull - ResolvedCall getResult(); + ResolvedCall getResultingCall(); + + @NotNull + D getResultingDescriptor(); @NotNull Code getResultCode(); boolean isSuccess(); - boolean singleDescriptor(); + boolean singleResult(); boolean isNothing(); 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 index 577c365b694..7225aa2ce39 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadResolutionResultsImpl.java @@ -9,7 +9,7 @@ import java.util.Collections; /** * @author abreslav */ -public class OverloadResolutionResultsImpl implements OverloadResolutionResults { +/*package*/ class OverloadResolutionResultsImpl implements OverloadResolutionResults { public static OverloadResolutionResultsImpl success(@NotNull ResolvedCallImpl descriptor) { return new OverloadResolutionResultsImpl(Code.SUCCESS, Collections.singleton(descriptor)); @@ -40,17 +40,23 @@ public class OverloadResolutionResultsImpl impleme @Override @NotNull - public Collection> getResults() { + public Collection> getResultingCalls() { return results; } @Override @NotNull - public ResolvedCallImpl getResult() { - assert singleDescriptor(); + public ResolvedCallImpl getResultingCall() { + assert singleResult(); return results.iterator().next(); } + @NotNull + @Override + public D getResultingDescriptor() { + return getResultingCall().getResultingDescriptor(); + } + @Override @NotNull public Code getResultCode() { @@ -63,7 +69,7 @@ public class OverloadResolutionResultsImpl impleme } @Override - public boolean singleDescriptor() { + public boolean singleResult() { return isSuccess() || resultCode == Code.SINGLE_CANDIDATE_ARGUMENT_MISMATCH; } 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 f3600ca8c13..94096c3e154 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 @@ -13,10 +13,10 @@ import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; 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.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; -import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResultsImpl; import org.jetbrains.jet.lang.resolve.constants.*; +import org.jetbrains.jet.lang.resolve.constants.StringValue; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver; @@ -30,7 +30,8 @@ import org.jetbrains.jet.lexer.JetTokens; 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.BindingContext.INDEXED_LVALUE_GET; +import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER; import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE; import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.*; @@ -584,10 +585,10 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) selectorExpression; TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace); - VariableDescriptor variableDescriptor = context.replaceBindingTrace(temporaryTrace).resolveSimpleProperty(receiver, callOperationNode, nameExpression); - if (variableDescriptor != null) { + OverloadResolutionResults variableDescriptor = context.replaceBindingTrace(temporaryTrace).resolveSimpleProperty(receiver, callOperationNode, nameExpression); + if (variableDescriptor.isSuccess()) { temporaryTrace.commit(); - return variableDescriptor.getOutType(); + return variableDescriptor.getResultingDescriptor().getOutType(); } ExpressionTypingContext newContext = receiver.exists() ? context.replaceScope(receiver.getType().getMemberScope()) : context; JetType jetType = lookupNamespaceOrClassObject(nameExpression, nameExpression.getReferencedName(), newContext); @@ -645,13 +646,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { ExpressionReceiver receiver = getExpressionReceiver(facade, baseExpression, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(context.scope)); if (receiver == null) return null; - FunctionDescriptor functionDescriptor = context.resolveCallWithGivenNameToDescriptor( + OverloadResolutionResults functionDescriptor = context.resolveCallWithGivenNameToDescriptor( CallMaker.makeCall(receiver, expression), expression.getOperationReference(), name); - if (functionDescriptor == null) return null; - JetType returnType = functionDescriptor.getReturnType(); + if (!functionDescriptor.isSuccess()) return null; + JetType returnType = functionDescriptor.getResultingDescriptor().getReturnType(); JetType result; if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) { if (context.semanticServices.getTypeChecker().isSubtypeOf(returnType, JetStandardClasses.getUnitType())) { @@ -740,11 +741,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { String name = "equals"; if (right != null) { ExpressionReceiver receiver = ExpressionTypingUtils.safeGetExpressionReceiver(facade, left, context.replaceScope(context.scope)); - OverloadResolutionResultsImpl resolutionResults = context.resolveExactSignature( + OverloadResolutionResults resolutionResults = context.resolveExactSignature( receiver, "equals", Collections.singletonList(JetStandardClasses.getNullableAnyType())); if (resolutionResults.isSuccess()) { - FunctionDescriptor equals = resolutionResults.getResult().getResultingDescriptor(); + FunctionDescriptor equals = resolutionResults.getResultingCall().getResultingDescriptor(); context.trace.record(REFERENCE_TARGET, operationSign, equals); if (ensureBooleanResult(operationSign, name, equals.getReturnType(), context)) { ensureNonemptyIntersectionOfOperandTypes(expression, context); @@ -752,7 +753,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } else { if (resolutionResults.isAmbiguity()) { - context.trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(operationSign, resolutionResults.getResults())); + context.trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(operationSign, resolutionResults.getResultingCalls())); } else { context.trace.report(EQUALS_MISSING.on(operationSign)); @@ -812,11 +813,11 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { public void checkInExpression(JetElement callElement, @NotNull JetSimpleNameExpression operationSign, @NotNull JetExpression left, @NotNull JetExpression right, ExpressionTypingContext context) { String name = "contains"; ExpressionReceiver receiver = safeGetExpressionReceiver(facade, right, context.replaceExpectedType(NO_EXPECTED_TYPE)); - FunctionDescriptor functionDescriptor = context.resolveCallWithGivenNameToDescriptor( + OverloadResolutionResults functionDescriptor = context.resolveCallWithGivenNameToDescriptor( CallMaker.makeCallWithExpressions(callElement, receiver, null, operationSign, Collections.singletonList(left)), operationSign, name); - JetType containsType = functionDescriptor != null ? functionDescriptor.getReturnType() : null; + JetType containsType = functionDescriptor.isSuccess() ? functionDescriptor.getResultingDescriptor().getReturnType() : null; ensureBooleanResult(operationSign, name, containsType, context); } @@ -860,14 +861,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { ExpressionReceiver receiver = getExpressionReceiver(facade, arrayExpression, context.replaceScope(context.scope)); if (receiver != null) { - ResolvedCall resolvedCall = context.resolveCallWithGivenName( + OverloadResolutionResults results = context.resolveCallWithGivenName( CallMaker.makeCallWithExpressions(expression, receiver, null, expression, expression.getIndexExpressions()), expression, "get" ); - if (resolvedCall != null) { - context.trace.record(INDEXED_LVALUE_GET, expression, resolvedCall); - return DataFlowUtils.checkType(resolvedCall.getResultingDescriptor().getReturnType(), expression, contextWithExpectedType); + if (results.isSuccess()) { + context.trace.record(INDEXED_LVALUE_GET, expression, results.getResultingCall()); + return DataFlowUtils.checkType(results.getResultingDescriptor().getReturnType(), expression, contextWithExpectedType); } } return null; @@ -876,13 +877,13 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Nullable public JetType getTypeForBinaryCall(JetScope scope, String name, ExpressionTypingContext context, JetBinaryExpression binaryExpression) { ExpressionReceiver receiver = safeGetExpressionReceiver(facade, binaryExpression.getLeft(), context.replaceScope(scope)); - FunctionDescriptor functionDescriptor = context.replaceScope(scope).resolveCallWithGivenNameToDescriptor( + OverloadResolutionResults results = context.replaceScope(scope).resolveCallWithGivenNameToDescriptor( CallMaker.makeCall(receiver, binaryExpression), binaryExpression.getOperationReference(), name ); - if (functionDescriptor != null) { - return functionDescriptor.getReturnType(); + if (results.isSuccess()) { + return results.getResultingDescriptor().getReturnType(); } return null; } 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 059baf138fe..4ba03453c46 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,8 +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.OverloadResolutionResultsImpl; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; 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; @@ -258,9 +258,9 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { @Nullable private JetType checkIterableConvention(@NotNull ExpressionReceiver loopRange, ExpressionTypingContext context) { JetExpression loopRangeExpression = loopRange.getExpression(); - OverloadResolutionResultsImpl iteratorResolutionResults = context.resolveExactSignature(loopRange, "iterator", Collections.emptyList()); + OverloadResolutionResults iteratorResolutionResults = context.resolveExactSignature(loopRange, "iterator", Collections.emptyList()); if (iteratorResolutionResults.isSuccess()) { - FunctionDescriptor iteratorFunction = iteratorResolutionResults.getResult().getResultingDescriptor(); + FunctionDescriptor iteratorFunction = iteratorResolutionResults.getResultingCall().getResultingDescriptor(); context.trace.record(LOOP_RANGE_ITERATOR, loopRangeExpression, iteratorFunction); @@ -280,13 +280,13 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { context.trace.record(LOOP_RANGE_HAS_NEXT, loopRange.getExpression(), hasNextFunctionSupported ? hasNextFunction : hasNextProperty); } - OverloadResolutionResultsImpl nextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "next", Collections.emptyList()); + OverloadResolutionResults nextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "next", Collections.emptyList()); if (nextResolutionResults.isAmbiguity()) { context.trace.report(NEXT_AMBIGUITY.on(loopRangeExpression)); } else if (nextResolutionResults.isNothing()) { context.trace.report(NEXT_MISSING.on(loopRangeExpression)); } else { - FunctionDescriptor nextFunction = nextResolutionResults.getResult().getResultingDescriptor(); + FunctionDescriptor nextFunction = nextResolutionResults.getResultingCall().getResultingDescriptor(); context.trace.record(LOOP_RANGE_NEXT, loopRange.getExpression(), nextFunction); return nextFunction.getReturnType(); } @@ -294,11 +294,11 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { else { if (iteratorResolutionResults.isAmbiguity()) { // StringBuffer stringBuffer = new StringBuffer("Method 'iterator()' is ambiguous for this expression: "); -// for (FunctionDescriptor functionDescriptor : iteratorResolutionResults.getResults()) { +// for (FunctionDescriptor functionDescriptor : iteratorResolutionResults.getResultingCalls()) { // stringBuffer.append(DescriptorRenderer.TEXT.render(functionDescriptor)).append(" "); // } // errorMessage = stringBuffer.toString(); - context.trace.report(ITERATOR_AMBIGUITY.on(loopRangeExpression, iteratorResolutionResults.getResults())); + context.trace.report(ITERATOR_AMBIGUITY.on(loopRangeExpression, iteratorResolutionResults.getResultingCalls())); } else { context.trace.report(ITERATOR_MISSING.on(loopRangeExpression)); @@ -309,19 +309,19 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { @Nullable private FunctionDescriptor checkHasNextFunctionSupport(@NotNull JetExpression loopRange, @NotNull JetType iteratorType, ExpressionTypingContext context) { - OverloadResolutionResultsImpl hasNextResolutionResults = context.resolveExactSignature(new TransientReceiver(iteratorType), "hasNext", Collections.emptyList()); + OverloadResolutionResults 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()) { return null; } else { assert hasNextResolutionResults.isSuccess(); - JetType hasNextReturnType = hasNextResolutionResults.getResult().getResultingDescriptor().getReturnType(); + JetType hasNextReturnType = hasNextResolutionResults.getResultingDescriptor().getReturnType(); if (!isBoolean(context.semanticServices, hasNextReturnType)) { context.trace.report(HAS_NEXT_FUNCTION_TYPE_MISMATCH.on(loopRange, hasNextReturnType)); } } - return hasNextResolutionResults.getResult().getResultingDescriptor(); + return hasNextResolutionResults.getResultingCall().getResultingDescriptor(); } @Nullable 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 3219126fdce..a6116fc2852 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 @@ -10,10 +10,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingTrace; 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.OverloadResolutionResultsImpl; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -173,30 +170,31 @@ import java.util.Map; ////////// Call resolution utilities - @Nullable - public ResolvedCall resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull String name) { + @NotNull + public OverloadResolutionResults resolveCallWithGivenName(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull String name) { return getCallResolver().resolveCallWithGivenName(trace, scope, call, functionReference, name, expectedType); } - @Nullable - public FunctionDescriptor resolveCallWithGivenNameToDescriptor(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull String name) { - ResolvedCall resolvedCall = resolveCallWithGivenName(call, functionReference, name); - return resolvedCall == null ? null : resolvedCall.getResultingDescriptor(); + @NotNull + public OverloadResolutionResults resolveCallWithGivenNameToDescriptor(@NotNull Call call, @NotNull JetReferenceExpression functionReference, @NotNull String name) { + return resolveCallWithGivenName(call, functionReference, name); +// return results == null ? null : results.getResultingDescriptor(); } @Nullable public JetType resolveCall(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetCallExpression callExpression) { - return getCallResolver().resolveCall(trace, scope, CallMaker.makeCall(receiver, callOperationNode, callExpression), expectedType); + OverloadResolutionResults results = getCallResolver().resolveCall(trace, scope, CallMaker.makeCall(receiver, callOperationNode, callExpression), expectedType); + return results.singleResult() ? results.getResultingDescriptor().getReturnType() : null; } - @Nullable - public VariableDescriptor resolveSimpleProperty(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) { + @NotNull + public OverloadResolutionResults resolveSimpleProperty(@NotNull ReceiverDescriptor receiver, @Nullable ASTNode callOperationNode, @NotNull JetSimpleNameExpression nameExpression) { Call call = CallMaker.makePropertyCall(receiver, callOperationNode, nameExpression); return getCallResolver().resolveSimpleProperty(trace, scope, call, expectedType); } @NotNull - public OverloadResolutionResultsImpl resolveExactSignature(@NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { + public OverloadResolutionResults resolveExactSignature(@NotNull ReceiverDescriptor receiver, @NotNull String name, @NotNull List parameterTypes) { return getCallResolver().resolveExactSignature(scope, receiver, name, parameterTypes); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java index 56ce116c9df..2bd86462462 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java @@ -11,7 +11,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; import org.jetbrains.jet.lang.resolve.TopDownAnalyzer; import org.jetbrains.jet.lang.resolve.calls.CallMaker; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; @@ -223,14 +223,14 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito if (receiver == null) return null; Call call = CallMaker.makeArraySetCall(receiver, arrayAccessExpression, rightHandSide); - ResolvedCall setFunctionCall = context.replaceScope(scope).replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).resolveCallWithGivenName( + OverloadResolutionResults setFunctionResults = context.replaceScope(scope).replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).resolveCallWithGivenName( call, arrayAccessExpression, "set"); - if (setFunctionCall == null) return null; - FunctionDescriptor setFunctionDescriptor = setFunctionCall.getResultingDescriptor(); + if (!setFunctionResults.isSuccess()) return null; + FunctionDescriptor setFunctionDescriptor = setFunctionResults.getResultingDescriptor(); - context.trace.record(INDEXED_LVALUE_SET, arrayAccessExpression, setFunctionCall); + context.trace.record(INDEXED_LVALUE_SET, arrayAccessExpression, setFunctionResults.getResultingCall()); // if (getterNeeded) { // ResolvedCall getFunctionCall = context.replaceScope(scope).replaceExpectedType(TypeUtils.NO_EXPECTED_TYPE).resolveCallWithGivenName( diff --git a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.jet b/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.jet index 7e36dc38033..852e49c45fe 100644 --- a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.jet +++ b/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.jet @@ -42,7 +42,7 @@ fun main(args : Array) { val b = fooT2()(1) b : Int - fooT2()(1) // : Any? + fooT2()(1) // : Any? 1() 1{} diff --git a/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.jet b/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.jet index 4436d18abf9..4ee535aae1f 100644 --- a/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.jet +++ b/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.jet @@ -1,9 +1,9 @@ -fun fooT2() : fun(t : T) : T { - return {it} +fun fooT22() : T? { + return null +} + +fun foo1() { + fooT22() } val n : Nothing = null.sure() - -fun test() { - fooT2()(1) -} diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index d8139d4ebd1..cca4e1ee90d 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -16,8 +16,8 @@ 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.OverloadResolutionResultsImpl; -import org.jetbrains.jet.lang.resolve.calls.ResolvedCallImpl; +import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults; +import org.jetbrains.jet.lang.resolve.calls.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetStandardLibrary; @@ -113,9 +113,9 @@ public class JetResolveTest extends ExtensibleResolveTestCase { // JetTypeInferrer.Services typeInferrerServices = JetSemanticServices.createSemanticServices(getProject()).getTypeInferrerServices(new BindingTraceContext()); CallResolver callResolver = new CallResolver(JetSemanticServices.createSemanticServices(getProject()), DataFlowInfo.EMPTY); - OverloadResolutionResultsImpl functions = callResolver.resolveExactSignature( + OverloadResolutionResults functions = callResolver.resolveExactSignature( classDescriptor.getMemberScope(typeArguments), ReceiverDescriptor.NO_RECEIVER, name, parameterTypeList); - for (ResolvedCallImpl resolvedCall : functions.getResults()) { + for (ResolvedCall resolvedCall : functions.getResultingCalls()) { List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i);