logic for fake value arguments creation

moved to 'resolveFakeCall' method

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<FunctionDescriptor> resolutionResults = resolveFakeCall(
-                            receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), Collections.<JetExpression>singletonList(fakeArgument), name);
+                            context, receiver, name, KotlinBuiltIns.getInstance().getNullableAnyType());
 
                     if (resolutionResults.isSuccess()) {
                         FunctionDescriptor equals = resolutionResults.getResultingCall().getResultingDescriptor();

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java

@@ -376,7 +376,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
             @NotNull WritableSlice<JetExpression, ResolvedCall<FunctionDescriptor>> resolvedCallKey
     ) {
         OverloadResolutionResults<FunctionDescriptor> nextResolutionResults = resolveFakeCall(
-                new TransientReceiver(iteratorType), context, Collections.<JetExpression>emptyList(), Name.identifier(name));
+                new TransientReceiver(iteratorType), context, Name.identifier(name));
         if (nextResolutionResults.isAmbiguity()) {
             context.trace.report(ambiguity.on(loopRangeExpression, iteratorType));
         }

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<FunctionDescriptor> 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<JetExpression> 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<FunctionDescriptor> resolveFakeCall(
             @NotNull ReceiverValue receiver,
             @NotNull ExpressionTypingContext context,
-            @NotNull List<JetExpression> valueArguments,
             @NotNull Name name
     ) {
-        return makeAndResolveFakeCall(receiver, context, valueArguments, name).getSecond();
+        return makeAndResolveFakeCall(receiver, context, Collections.<JetExpression>emptyList(), name).getSecond();
     }
 
     @NotNull
@@ -320,7 +336,7 @@ public class ExpressionTypingUtils {
 
             JetType expectedType = getExpectedTypeForComponent(context, entry);
             OverloadResolutionResults<FunctionDescriptor> results =
-                    resolveFakeCall(receiver, context.replaceExpectedType(expectedType), Collections.<JetExpression>emptyList(), componentName);
+                    resolveFakeCall(receiver, context.replaceExpectedType(expectedType), componentName);
 
             JetType componentType = null;
             if (results.isSuccess()) {

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<JetType> parameterTypeList = Arrays.asList(parameterTypes);
-
-        TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(new BindingTraceContext(),
-                                                                                       "trace to store fake argument for", name);
-        int index = 0;
-        List<JetExpression> 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<FunctionDescriptor> functions = resolveFakeCall(
-                ReceiverValue.NO_RECEIVER, context, valueArguments, Name.identifier(name));
+                context, ReceiverValue.NO_RECEIVER, Name.identifier(name), parameterTypes);
 
         for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {
             List<ValueParameterDescriptor> 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