From 82e9d1f4fa99d3aa0eb1600b961e725db4aefd37 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Fri, 2 Nov 2012 16:22:19 +0400 Subject: [PATCH] logic for fake value arguments creation moved to 'resolveFakeCall' method --- .../BasicExpressionTypingVisitor.java | 7 +----- .../ControlStructureTypingVisitor.java | 2 +- .../expressions/ExpressionTypingUtils.java | 22 ++++++++++++++--- .../jetbrains/jet/resolve/JetResolveTest.java | 24 ++++--------------- 4 files changed, 25 insertions(+), 30 deletions(-) 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 7c77b798067..911a1875009 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 @@ -1089,13 +1089,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { if (right != null) { ExpressionReceiver receiver = ExpressionTypingUtils.safeGetExpressionReceiver(facade, left, context.replaceScope(context.scope)); - final JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName( - context.expressionTypingServices.getProject(), "fakeArgument"); - TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name); - traceWithFakeArgumentInfo.record(EXPRESSION_TYPE, fakeArgument, KotlinBuiltIns.getInstance().getNullableAnyType()); - OverloadResolutionResults resolutionResults = resolveFakeCall( - receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), Collections.singletonList(fakeArgument), name); + context, receiver, name, KotlinBuiltIns.getInstance().getNullableAnyType()); if (resolutionResults.isSuccess()) { FunctionDescriptor equals = resolutionResults.getResultingCall().getResultingDescriptor(); 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 5778c0f095d..fbf89a009a2 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 @@ -376,7 +376,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { @NotNull WritableSlice> resolvedCallKey ) { OverloadResolutionResults nextResolutionResults = resolveFakeCall( - new TransientReceiver(iteratorType), context, Collections.emptyList(), Name.identifier(name)); + new TransientReceiver(iteratorType), context, Name.identifier(name)); if (nextResolutionResults.isAmbiguity()) { context.trace.report(ambiguity.on(loopRangeExpression, iteratorType)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index ddfa5f369b3..fd444d29892 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.lang.types.expressions; +import com.google.common.collect.Lists; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; @@ -271,14 +272,29 @@ public class ExpressionTypingUtils { return typeNames; } + @NotNull + public static OverloadResolutionResults resolveFakeCall( + @NotNull ExpressionTypingContext context, @NotNull ReceiverValue receiver, + @NotNull Name name, @NotNull JetType... argumentTypes + ) { + TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name); + int index = 0; + List fakeArguments = Lists.newArrayList(); + for (JetType type : argumentTypes) { + final JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName(context.expressionTypingServices.getProject(), "fakeArgument" + index++); + fakeArguments.add(fakeArgument); + traceWithFakeArgumentInfo.record(EXPRESSION_TYPE, fakeArgument, type); + } + return makeAndResolveFakeCall(receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), fakeArguments, name).getSecond(); + } + @NotNull public static OverloadResolutionResults resolveFakeCall( @NotNull ReceiverValue receiver, @NotNull ExpressionTypingContext context, - @NotNull List valueArguments, @NotNull Name name ) { - return makeAndResolveFakeCall(receiver, context, valueArguments, name).getSecond(); + return makeAndResolveFakeCall(receiver, context, Collections.emptyList(), name).getSecond(); } @NotNull @@ -320,7 +336,7 @@ public class ExpressionTypingUtils { JetType expectedType = getExpectedTypeForComponent(context, entry); OverloadResolutionResults results = - resolveFakeCall(receiver, context.replaceExpectedType(expectedType), Collections.emptyList(), componentName); + resolveFakeCall(receiver, context.replaceExpectedType(expectedType), componentName); JetType componentType = null; if (results.isSuccess()) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 3d34597c6cb..c989830a696 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.resolve; -import com.google.common.collect.Lists; import com.intellij.openapi.application.PathManager; import com.intellij.openapi.project.Project; import com.intellij.psi.JavaPsiFacade; @@ -32,12 +31,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; 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.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; -import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults; @@ -58,7 +53,6 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import static org.jetbrains.jet.lang.resolve.BindingContext.EXPRESSION_TYPE; import static org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils.resolveFakeCall; /** @@ -140,26 +134,15 @@ public class JetResolveTest extends ExtensibleResolveTestCase { @NotNull private FunctionDescriptor standardFunction(ClassDescriptor classDescriptor, String name, JetType... parameterTypes) { - List parameterTypeList = Arrays.asList(parameterTypes); - - TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(new BindingTraceContext(), - "trace to store fake argument for", name); - int index = 0; - List valueArguments = Lists.newArrayList(); - for (JetType type : parameterTypeList) { - final JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName(getProject(), "fakeArgument" + index++); - valueArguments.add(fakeArgument); - traceWithFakeArgumentInfo.record(EXPRESSION_TYPE, fakeArgument, type); - } ExpressionTypingServices expressionTypingServices = new InjectorForTests(getProject()).getExpressionTypingServices(); ExpressionTypingContext context = ExpressionTypingContext.newContext( - expressionTypingServices, traceWithFakeArgumentInfo, classDescriptor.getDefaultType().getMemberScope(), + expressionTypingServices, new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(), DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE, false); OverloadResolutionResults functions = resolveFakeCall( - ReceiverValue.NO_RECEIVER, context, valueArguments, Name.identifier(name)); + context, ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypes); for (ResolvedCall resolvedCall : functions.getResultingCalls()) { List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters(); @@ -170,7 +153,8 @@ public class JetResolveTest extends ExtensibleResolveTestCase { } } } - throw new IllegalArgumentException("Not found: kotlin::" + classDescriptor.getName() + "." + name + "(" + parameterTypeList + ")"); + throw new IllegalArgumentException("Not found: kotlin::" + classDescriptor.getName() + "." + name + "(" + + Arrays.toString(parameterTypes) + ")"); } @Override