From 6739f7ca2485e7f5e2b19b7d8b451e2b80b770b1 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Wed, 20 Feb 2013 12:39:46 +0400 Subject: [PATCH] refactoring: invocation 'getArgumentTypeInfo' changed to 'getFunctionLiteralTypeInfo' for function literals --- .../resolve/calls/ArgumentTypeResolver.java | 21 +++++++++++++++---- .../lang/resolve/calls/CandidateResolver.java | 6 ++++-- 2 files changed, 21 insertions(+), 6 deletions(-) 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 59f2dd83f64..c2fbe10bfea 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 @@ -36,6 +36,7 @@ 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; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; @@ -163,14 +164,13 @@ public class ArgumentTypeResolver { public TypeInfoForCall getArgumentTypeInfo( @Nullable JetExpression expression, @NotNull CallResolutionContext context, - @NotNull ResolveArgumentsMode resolveFunctionArgumentBodies + @NotNull ResolveArgumentsMode resolveArgumentsMode ) { if (expression == null) { return TypeInfoForCall.create(null, context.dataFlowInfo); } - if (expression instanceof JetFunctionLiteralExpression && resolveFunctionArgumentBodies == SKIP_FUNCTION_ARGUMENTS) { - JetType type = getFunctionLiteralType((JetFunctionLiteralExpression) expression, context.scope, context.trace); - return TypeInfoForCall.create(type, context.dataFlowInfo); + if (expression instanceof JetFunctionLiteralExpression) { + return TypeInfoForCall.create(getFunctionLiteralTypeInfo((JetFunctionLiteralExpression) expression, context, resolveArgumentsMode)); } TypeInfoForCall cachedTypeInfo = getRecordedTypeInfoForCall(expression, context); if (cachedTypeInfo != null) { @@ -200,6 +200,19 @@ public class ArgumentTypeResolver { expressionTypingServices.getTypeInfo(context.scope, expression, context.expectedType, context.dataFlowInfo, context.trace)); } + @NotNull + public JetTypeInfo getFunctionLiteralTypeInfo( + @NotNull JetFunctionLiteralExpression functionLiteralExpression, + @NotNull CallResolutionContext context, + @NotNull ResolveArgumentsMode resolveArgumentsMode + ) { + if (resolveArgumentsMode == SKIP_FUNCTION_ARGUMENTS) { + JetType type = getFunctionLiteralType(functionLiteralExpression, context.scope, context.trace); + return JetTypeInfo.create(type, context.dataFlowInfo); + } + return expressionTypingServices.getTypeInfo(context.scope, functionLiteralExpression, context.expectedType, context.dataFlowInfo, context.trace); + } + @Nullable private JetType getFunctionLiteralType( @NotNull JetFunctionLiteralExpression expression, 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 2f3753828b5..257ab9d490f 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 @@ -335,7 +335,8 @@ public class CandidateResolver { traceToResolveFunctionLiteral, statementExpression, mismatch); CallCandidateResolutionContext newContext = context.replaceBindingTrace(errorInterceptingTrace).replaceExpectedType(expectedType); - JetType type = argumentTypeResolver.getArgumentTypeInfo(argumentExpression, newContext, RESOLVE_FUNCTION_ARGUMENTS).getType(); + JetType type = argumentTypeResolver.getFunctionLiteralTypeInfo((JetFunctionLiteralExpression) argumentExpression, newContext, + RESOLVE_FUNCTION_ARGUMENTS).getType(); if (!mismatch[0]) { constraintSystem.addSubtypeConstraint( type, effectiveExpectedType, ConstraintPosition.getValueParameterPosition(valueParameterDescriptor.getIndex())); @@ -346,7 +347,8 @@ public class CandidateResolver { } JetType expectedTypeWithoutReturnType = hasExpectedReturnType ? CallResolverUtil.replaceReturnTypeByUnknown(expectedType) : expectedType; CallCandidateResolutionContext newContext = context.replaceExpectedType(expectedTypeWithoutReturnType); - JetType type = argumentTypeResolver.getArgumentTypeInfo(argumentExpression, newContext, RESOLVE_FUNCTION_ARGUMENTS).getType(); + JetType type = argumentTypeResolver.getFunctionLiteralTypeInfo((JetFunctionLiteralExpression) argumentExpression, newContext, + RESOLVE_FUNCTION_ARGUMENTS).getType(); constraintSystem.addSubtypeConstraint( type, effectiveExpectedType, ConstraintPosition.getValueParameterPosition(valueParameterDescriptor.getIndex())); }