From 67925fcda448f8689cf61e8050270ef80ad09d71 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 6 Sep 2011 15:54:46 +0400 Subject: [PATCH] Wrong trace in call resolver fixed --- .../jet/lang/resolve/AnnotationResolver.java | 1 + .../jet/lang/resolve/calls/CallResolver.java | 14 +++----- .../jet/lang/types/JetTypeInferrer.java | 33 ++++++++++--------- .../regression/WrongTraceInCallResolver.jet | 9 +++++ 4 files changed, 32 insertions(+), 25 deletions(-) create mode 100644 idea/testData/checker/regression/WrongTraceInCallResolver.jet diff --git a/idea/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java index 51f97050489..45b58351814 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java @@ -22,6 +22,7 @@ public class AnnotationResolver { private final BindingTrace trace; public AnnotationResolver(JetSemanticServices semanticServices, BindingTrace trace) { + this.trace = trace; } diff --git a/idea/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 9564e0018e2..062cd490308 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -27,16 +27,12 @@ import static org.jetbrains.jet.lang.types.JetTypeInferrer.NO_EXPECTED_TYPE; */ public class CallResolver { - private final TypeResolver typeResolver; private final JetTypeInferrer typeInferrer; private final JetSemanticServices semanticServices; - private final ClassDescriptorResolver classDescriptorResolver; private final OverloadingConflictResolver overloadingConflictResolver; - public CallResolver(JetSemanticServices semanticServices, BindingTrace trace, JetTypeInferrer typeInferrer) { + public CallResolver(JetSemanticServices semanticServices, JetTypeInferrer typeInferrer) { this.typeInferrer = typeInferrer; - this.typeResolver = new TypeResolver(semanticServices, trace, true); - this.classDescriptorResolver = semanticServices.getClassDescriptorResolver(trace); this.semanticServices = semanticServices; this.overloadingConflictResolver = new OverloadingConflictResolver(semanticServices); } @@ -114,7 +110,7 @@ public class CallResolver { } JetTypeReference typeReference = expression.getTypeReference(); assert typeReference != null; - JetType constructedType = typeResolver.resolveType(scope, typeReference); + JetType constructedType = new TypeResolver(semanticServices, trace, true).resolveType(scope, typeReference); DeclarationDescriptor declarationDescriptor = constructedType.getConstructor().getDeclarationDescriptor(); if (declarationDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; @@ -360,7 +356,7 @@ public class CallResolver { } } - checkGenericBoundsInAFunctionCall(jetTypeArguments, typeArguments, candidate); + checkGenericBoundsInAFunctionCall(jetTypeArguments, typeArguments, candidate, temporaryTrace); Map substitutionContext = FunctionDescriptorUtil.createSubstitutionContext((FunctionDescriptor) candidate, typeArguments); D substitutedFunctionDescriptor = (D) candidate.substitute(TypeSubstitutor.create(substitutionContext)); @@ -544,7 +540,7 @@ public class CallResolver { return result; } - public void checkGenericBoundsInAFunctionCall(List jetTypeArguments, List typeArguments, CallableDescriptor functionDescriptor) { + public void checkGenericBoundsInAFunctionCall(List jetTypeArguments, List typeArguments, CallableDescriptor functionDescriptor, BindingTrace trace) { Map context = Maps.newHashMap(); List typeParameters = functionDescriptor.getOriginal().getTypeParameters(); @@ -559,7 +555,7 @@ public class CallResolver { JetType typeArgument = typeArguments.get(i); JetTypeReference typeReference = jetTypeArguments.get(i).getTypeReference(); assert typeReference != null; - classDescriptorResolver.checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor); + semanticServices.getClassDescriptorResolver(trace).checkBounds(typeReference, typeArgument, typeParameterDescriptor, substitutor); } } diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index bc489c5be1d..4a5a91d4103 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -155,12 +155,15 @@ public class JetTypeInferrer { private final JetSemanticServices semanticServices; private final JetFlowInformationProvider flowInformationProvider; + private final CallResolver callResolver; private final Map patternsToDataFlowInfo = Maps.newHashMap(); + private final Map> patternsToBoundVariableLists = Maps.newHashMap(); - + public JetTypeInferrer(@NotNull JetFlowInformationProvider flowInformationProvider, @NotNull JetSemanticServices semanticServices) { this.semanticServices = semanticServices; this.flowInformationProvider = flowInformationProvider; + this.callResolver = new CallResolver(semanticServices, this); } public Services getServices(@NotNull BindingTrace trace) { @@ -170,7 +173,6 @@ public class JetTypeInferrer { public class Services { private final BindingTrace trace; private final CompileTimeConstantResolver compileTimeConstantResolver; - private final CallResolver callResolver; private final TypeInferrerVisitor typeInferrerVisitor; private final TypeInferrerVisitorWithNamespaces typeInferrerVisitorWithNamespaces; @@ -180,7 +182,6 @@ public class JetTypeInferrer { this.compileTimeConstantResolver = new CompileTimeConstantResolver(semanticServices, trace); this.typeInferrerVisitor = new TypeInferrerVisitor(); this.typeInferrerVisitorWithNamespaces = new TypeInferrerVisitorWithNamespaces(); - this.callResolver = new CallResolver(semanticServices, trace, JetTypeInferrer.this); } public TypeInferrerVisitorWithWritableScope newTypeInferrerVisitorWithWritableScope(WritableScope scope) { @@ -1830,7 +1831,7 @@ public class JetTypeInferrer { @Nullable private JetType checkIterableConvention(@NotNull JetType type, @NotNull JetExpression loopRange, TypeInferenceContext context) { ASTNode reportErrorsOn = loopRange.getNode(); - OverloadResolutionResult iteratorResolutionResult = context.services.callResolver.resolveExactSignature(context.scope, type, "iterator", Collections.emptyList()); + OverloadResolutionResult iteratorResolutionResult = callResolver.resolveExactSignature(context.scope, type, "iterator", Collections.emptyList()); if (iteratorResolutionResult.isSuccess()) { FunctionDescriptor iteratorFunction = iteratorResolutionResult.getDescriptor(); @@ -1852,7 +1853,7 @@ public class JetTypeInferrer { context.trace.record(LOOP_RANGE_HAS_NEXT, loopRange, hasNextFunctionSupported ? hasNextFunction : hasNextProperty); } - OverloadResolutionResult nextResolutionResult = context.services.callResolver.resolveExactSignature(context.scope, iteratorType, "next", Collections.emptyList()); + OverloadResolutionResult nextResolutionResult = callResolver.resolveExactSignature(context.scope, iteratorType, "next", Collections.emptyList()); if (nextResolutionResult.isAmbiguity()) { context.trace.getErrorHandler().genericError(reportErrorsOn, "Method 'iterator().next()' is ambiguous for this expression"); } else if (nextResolutionResult.isNothing()) { @@ -1879,7 +1880,7 @@ public class JetTypeInferrer { @Nullable private FunctionDescriptor checkHasNextFunctionSupport(@NotNull JetExpression loopRange, @NotNull JetType iteratorType, TypeInferenceContext context) { - OverloadResolutionResult hasNextResolutionResult = context.services.callResolver.resolveExactSignature(context.scope, iteratorType, "hasNext", Collections.emptyList()); + OverloadResolutionResult hasNextResolutionResult = callResolver.resolveExactSignature(context.scope, iteratorType, "hasNext", Collections.emptyList()); if (hasNextResolutionResult.isAmbiguity()) { context.trace.getErrorHandler().genericError(loopRange.getNode(), "Method 'iterator().hasNext()' is ambiguous for this expression"); } else if (hasNextResolutionResult.isNothing()) { @@ -2080,13 +2081,13 @@ public class JetTypeInferrer { @Nullable private JetType getSelectorReturnType(@Nullable JetType receiverType, @NotNull JetExpression selectorExpression, @NotNull TypeInferenceContext context) { if (selectorExpression instanceof JetCallExpression) { - return context.services.callResolver.resolveCall(context.trace, context.scope, receiverType, (JetCallExpression) selectorExpression, context.expectedType); + return callResolver.resolveCall(context.trace, context.scope, receiverType, (JetCallExpression) selectorExpression, context.expectedType); } else if (selectorExpression instanceof JetSimpleNameExpression) { JetSimpleNameExpression nameExpression = (JetSimpleNameExpression) selectorExpression; TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(context.trace); - VariableDescriptor variableDescriptor = context.services.callResolver.resolveSimpleProperty(temporaryTrace, context.scope, receiverType, nameExpression, context.expectedType); + VariableDescriptor variableDescriptor = callResolver.resolveSimpleProperty(temporaryTrace, context.scope, receiverType, nameExpression, context.expectedType); if (variableDescriptor != null) { temporaryTrace.commit(); return context.services.checkEnrichedType(variableDescriptor.getOutType(), nameExpression, context); @@ -2117,7 +2118,7 @@ public class JetTypeInferrer { @Override public JetType visitCallExpression(JetCallExpression expression, TypeInferenceContext context) { - JetType expressionType = context.services.callResolver.resolveCall(context.trace, context.scope, null, expression, context.expectedType); + JetType expressionType = callResolver.resolveCall(context.trace, context.scope, null, expression, context.expectedType); return context.services.checkType(expressionType, expression, context); } @@ -2153,7 +2154,7 @@ public class JetTypeInferrer { JetType receiverType = getType(baseExpression, context.replaceExpectedType(NO_EXPECTED_TYPE).replaceScope(context.scope)); if (receiverType == null) return null; - FunctionDescriptor functionDescriptor = context.services.callResolver.resolveCallWithGivenName( + FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName( context.trace, context.scope, CallMaker.makeCall(expression), @@ -2228,7 +2229,7 @@ public class JetTypeInferrer { String name = "equals"; if (right != null) { JetType leftType = safeGetType(left, context.replaceScope(context.scope)); - OverloadResolutionResult resolutionResult = context.services.callResolver.resolveExactSignature( + OverloadResolutionResult resolutionResult = callResolver.resolveExactSignature( context.scope, leftType, "equals", Collections.singletonList(JetStandardClasses.getNullableAnyType())); if (resolutionResult.isSuccess()) { @@ -2303,7 +2304,7 @@ public class JetTypeInferrer { private void checkInExpression(JetSimpleNameExpression operationSign, JetExpression left, JetExpression right, TypeInferenceContext context) { String name = "contains"; JetType receiverType = context.services.safeGetType(context.scope, right, NO_EXPECTED_TYPE); - FunctionDescriptor functionDescriptor = context.services.callResolver.resolveCallWithGivenName( + FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName( context.trace, context.scope, CallMaker.makeCall(operationSign, Collections.singletonList(left)), @@ -2371,7 +2372,7 @@ public class JetTypeInferrer { JetType receiverType = getType(arrayExpression, context.replaceScope(context.scope)); if (receiverType != null) { - FunctionDescriptor functionDescriptor = context.services.callResolver.resolveCallWithGivenName( + FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName( context.trace, context.scope, CallMaker.makeCall(expression, expression.getIndexExpressions()), @@ -2389,7 +2390,7 @@ public class JetTypeInferrer { @Nullable protected JetType getTypeForBinaryCall(JetScope scope, String name, TypeInferenceContext context, JetBinaryExpression binaryExpression) { JetType leftType = getType(binaryExpression.getLeft(), context.replaceScope(scope)); - FunctionDescriptor functionDescriptor = context.services.callResolver.resolveCallWithGivenName( + FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName( context.trace, scope, CallMaker.makeCall(binaryExpression), @@ -2635,12 +2636,12 @@ public class JetTypeInferrer { // Call call = CallMaker.makeCall(arrayAccessExpression, rightHandSide); // // TODO : nasty hack: effort is duplicated -// context.services.callResolver.resolveCallWithGivenName( +// callResolver.resolveCallWithGivenName( // scope, // call, // arrayAccessExpression, // "set", arrayAccessExpression.getArrayExpression(), NO_EXPECTED_TYPE); - FunctionDescriptor functionDescriptor = context.services.callResolver.resolveCallWithGivenName( + FunctionDescriptor functionDescriptor = callResolver.resolveCallWithGivenName( context.trace, scope, call, diff --git a/idea/testData/checker/regression/WrongTraceInCallResolver.jet b/idea/testData/checker/regression/WrongTraceInCallResolver.jet new file mode 100644 index 00000000000..2c88d2450dd --- /dev/null +++ b/idea/testData/checker/regression/WrongTraceInCallResolver.jet @@ -0,0 +1,9 @@ +open class Foo {} +open class Bar {} + +fun foo(x : Int) {} +fun foo(x : Long) {} + +fun f(): Unit { + foo<Int, Int>(1) +} \ No newline at end of file