From ecd64e80d8e4a675c6cf1f70f460397d2c8ac19b Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Mon, 28 Jan 2013 18:37:54 +0400 Subject: [PATCH] use CallExpressionResolver directly from ArgumentTypeResolver --- .../jet/lang/resolve/BindingContextUtils.java | 19 ++++++++++++ .../resolve/calls/ArgumentTypeResolver.java | 31 ++++++++++++------- .../resolve/calls/CallExpressionResolver.java | 10 +++++- .../lang/resolve/calls/CandidateResolver.java | 20 +++++++----- .../BasicExpressionTypingVisitor.java | 3 +- 5 files changed, 60 insertions(+), 23 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java index af8a1c5ff3e..afce1470d92 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContextUtils.java @@ -23,6 +23,10 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.JetTypeInfo; import org.jetbrains.jet.util.slicedmap.ReadOnlySlice; import org.jetbrains.jet.util.slicedmap.Slices; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -277,4 +281,19 @@ public class BindingContextUtils { } }, false); } + + public static JetTypeInfo recordExpressionType(@NotNull JetExpression expression, @NotNull ResolutionContext context, @NotNull JetTypeInfo result) { + JetType type = result.getType(); + if (type != null) { + context.trace.record(BindingContext.EXPRESSION_TYPE, expression, type); + } + context.trace.record(BindingContext.PROCESSED, expression); + if (result.getDataFlowInfo() != DataFlowInfo.EMPTY) { + context.trace.record(BindingContext.EXPRESSION_DATA_FLOW_INFO, expression, result.getDataFlowInfo()); + } + if (!(expression instanceof JetReferenceExpression)) { + context.trace.record(BindingContext.RESOLUTION_SCOPE, expression, context.scope); + } + return result; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java index 717bc283493..98c4a66ec11 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java @@ -24,14 +24,12 @@ import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; -import org.jetbrains.jet.lang.resolve.TypeResolver; -import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.JetTypeInfo; @@ -45,6 +43,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import static org.jetbrains.jet.lang.resolve.BindingContextUtils.recordExpressionType; import static org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.*; import static org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.ResolveMode.RESOLVE_FUNCTION_ARGUMENTS; import static org.jetbrains.jet.lang.resolve.calls.CallResolverUtil.ResolveMode.SKIP_FUNCTION_ARGUMENTS; @@ -158,20 +157,28 @@ public class ArgumentTypeResolver { @NotNull public JetTypeInfo getArgumentTypeInfo( @Nullable JetExpression expression, - @NotNull BindingTrace trace, - @NotNull JetScope scope, - @NotNull DataFlowInfo dataFlowInfo, - @NotNull JetType expectedType, + @NotNull CallResolutionContext context, @NotNull ResolveMode resolveFunctionArgumentBodies ) { if (expression == null) { - return JetTypeInfo.create(null, dataFlowInfo); + return JetTypeInfo.create(null, context.dataFlowInfo); } if (expression instanceof JetFunctionLiteralExpression && resolveFunctionArgumentBodies == SKIP_FUNCTION_ARGUMENTS) { - JetType type = getFunctionLiteralType((JetFunctionLiteralExpression) expression, scope, trace); - return JetTypeInfo.create(type, dataFlowInfo); + JetType type = getFunctionLiteralType((JetFunctionLiteralExpression) expression, context.scope, context.trace); + return JetTypeInfo.create(type, context.dataFlowInfo); } - return expressionTypingServices.getTypeInfo(scope, expression, expectedType, dataFlowInfo, trace); + //todo deparenthesize + CallExpressionResolver callExpressionResolver = expressionTypingServices.getCallExpressionResolver(); + if (expression instanceof JetCallExpression) { + JetTypeInfo typeInfo = callExpressionResolver.getCallExpressionTypeInfo( + (JetCallExpression) expression, ReceiverValue.NO_RECEIVER, null, context); + return recordExpressionType(expression, context, typeInfo); + } + if (expression instanceof JetQualifiedExpression) { + JetTypeInfo typeInfo = callExpressionResolver.getQualifiedExpressionTypeInfo((JetQualifiedExpression) expression, context); + return recordExpressionType(expression, context, typeInfo); + } + return expressionTypingServices.getTypeInfo(context.scope, expression, context.expectedType, context.dataFlowInfo, context.trace); } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java index e02eb985b46..e23e31bff20 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java @@ -233,6 +233,13 @@ public class CallExpressionResolver { @NotNull public JetTypeInfo getCallExpressionTypeInfo(@NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver, @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context) { + JetTypeInfo typeInfo = getCallExpressionTypeInfoWithoutFinalTypeCheck(callExpression, receiver, callOperationNode, context); + return DataFlowUtils.checkType(typeInfo.getType(), callExpression, context, typeInfo.getDataFlowInfo()); + } + + @NotNull + private JetTypeInfo getCallExpressionTypeInfoWithoutFinalTypeCheck(@NotNull JetCallExpression callExpression, @NotNull ReceiverValue receiver, + @Nullable ASTNode callOperationNode, @NotNull ResolutionContext context) { boolean[] result = new boolean[1]; Call call = CallMaker.makeCall(receiver, callOperationNode, callExpression); @@ -295,7 +302,8 @@ public class CallExpressionResolver { @NotNull ResolutionContext context ) { if (selectorExpression instanceof JetCallExpression) { - return getCallExpressionTypeInfo((JetCallExpression) selectorExpression, receiver, callOperationNode, context); + return getCallExpressionTypeInfoWithoutFinalTypeCheck( + (JetCallExpression) selectorExpression, receiver, callOperationNode, context); } else if (selectorExpression instanceof JetSimpleNameExpression) { return getSimpleNameExpressionTypeInfo((JetSimpleNameExpression) selectorExpression, receiver, callOperationNode, context); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java index 8b41d8d7871..887abc2d10a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.*; import org.jetbrains.jet.lang.resolve.calls.context.CallCandidateResolutionContext; import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext; +import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext; import org.jetbrains.jet.lang.resolve.calls.inference.*; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl; @@ -349,12 +350,12 @@ public class CandidateResolver { return OTHER_ERROR.combine(argumentsStatus); } - private void addConstraintForValueArgument( + private > void addConstraintForValueArgument( @NotNull ValueArgument valueArgument, @NotNull ValueParameterDescriptor valueParameterDescriptor, @NotNull TypeSubstitutor substitutor, @NotNull ConstraintSystem constraintSystem, - @NotNull CallResolutionContext context, + @NotNull CallResolutionContext context, @Nullable boolean[] isErrorType, @NotNull ResolveMode resolveFunctionArgumentBodies) { @@ -363,8 +364,9 @@ public class CandidateResolver { TemporaryBindingTrace traceForUnknown = TemporaryBindingTrace.create( context.trace, "transient trace to resolve argument", argumentExpression); JetType expectedType = substitutor.substitute(effectiveExpectedType, Variance.INVARIANT); - JetType type = argumentTypeResolver.getArgumentTypeInfo(argumentExpression, traceForUnknown, context.scope, context.dataFlowInfo, - expectedType != null ? expectedType : NO_EXPECTED_TYPE, resolveFunctionArgumentBodies).getType(); + CallResolutionContext newContext = + context.replaceBindingTrace(traceForUnknown).replaceExpectedType(expectedType != null ? expectedType : NO_EXPECTED_TYPE); + JetType type = argumentTypeResolver.getArgumentTypeInfo(argumentExpression, newContext, resolveFunctionArgumentBodies).getType(); constraintSystem.addSubtypeConstraint(type, effectiveExpectedType, ConstraintPosition.getValueParameterPosition( valueParameterDescriptor.getIndex())); BindingContextUtils.commitResolutionCacheData(traceForUnknown, context.trace); @@ -396,8 +398,8 @@ public class CandidateResolver { return new ValueArgumentsCheckingResult(resultStatus, checkingResult.argumentTypes); } - private ValueArgumentsCheckingResult checkValueArgumentTypes( - @NotNull CallResolutionContext context, + private > ValueArgumentsCheckingResult checkValueArgumentTypes( + @NotNull CallResolutionContext context, @NotNull ResolvedCallImpl candidateCall, @NotNull BindingTrace trace, @NotNull ResolveMode resolveFunctionArgumentBodies) { @@ -416,8 +418,10 @@ public class CandidateResolver { if (TypeUtils.dependsOnTypeParameters(expectedType, candidateCall.getCandidateDescriptor().getTypeParameters())) { expectedType = NO_EXPECTED_TYPE; } - JetTypeInfo typeInfo = argumentTypeResolver.getArgumentTypeInfo(expression, trace, context.scope, candidateCall.getDataFlowInfo(), - expectedType, resolveFunctionArgumentBodies); + CallResolutionContext newContext = context.replaceDataFlowInfo(candidateCall.getDataFlowInfo()).replaceBindingTrace(trace) + .replaceExpectedType(expectedType); + JetTypeInfo typeInfo = argumentTypeResolver.getArgumentTypeInfo( + expression, newContext, resolveFunctionArgumentBodies); JetType type = typeInfo.getType(); candidateCall.addDataFlowInfo(typeInfo.getDataFlowInfo()); 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 e4943f35551..689b9b3160f 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 @@ -597,8 +597,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { @Override public JetTypeInfo visitCallExpression(JetCallExpression expression, ExpressionTypingContext context) { CallExpressionResolver callExpressionResolver = context.expressionTypingServices.getCallExpressionResolver(); - JetTypeInfo expressionTypeInfo = callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context); - return DataFlowUtils.checkType(expressionTypeInfo.getType(), expression, context, expressionTypeInfo.getDataFlowInfo()); + return callExpressionResolver.getCallExpressionTypeInfo(expression, NO_RECEIVER, null, context); } @Override