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 134a853ea85..a6bee531df6 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
@@ -766,7 +766,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
         // a[i]++/-- takes special treatment because it is actually let j = i, arr = a in arr.set(j, a.get(j).inc())
         if ((operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) && baseExpression instanceof JetArrayAccessExpression) {
-            JetExpression stubExpression = ExpressionTypingUtils.createStubExpressionOfNecessaryType(baseExpression.getProject(), type, context.trace);
+            JetExpression stubExpression = ExpressionTypingUtils.createFakeExpressionOfType(baseExpression.getProject(), context.trace, "$e", type);
             resolveArrayAccessSetMethod((JetArrayAccessExpression) baseExpression,
                                         stubExpression,
                                         context.replaceExpectedType(NO_EXPECTED_TYPE).replaceBindingTrace(
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 7c7917adc3c..1e1d6e9f60d 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
@@ -205,14 +205,6 @@ public class ExpressionTypingUtils {
             }
         }
     }
-    
-    @NotNull
-    public static JetExpression createStubExpressionOfNecessaryType(@NotNull Project project, @NotNull JetType type, @NotNull BindingTrace trace) {
-        JetExpression expression = JetPsiFactory.createExpression(project, "$e");
-        trace.record(PROCESSED, expression);
-        trace.record(EXPRESSION_TYPE, expression, type);
-        return expression;
-    }
 
     public static boolean isVariableIterable(@NotNull ExpressionTypingServices expressionTypingServices,
             @NotNull Project project, @NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope) {
@@ -339,18 +331,28 @@ public class ExpressionTypingUtils {
             @NotNull Name name,
             @NotNull JetType... argumentTypes
     ) {
-        TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for", name);
-        int index = 0;
+        TemporaryBindingTrace traceWithFakeArgumentInfo = TemporaryBindingTrace.create(context.trace, "trace to store fake argument for",
+                                                                                       name);
         List<JetExpression> fakeArguments = Lists.newArrayList();
         for (JetType type : argumentTypes) {
-            JetReferenceExpression fakeArgument = JetPsiFactory.createSimpleName(context.expressionTypingServices.getProject(), "fakeArgument" + index++);
-            fakeArguments.add(fakeArgument);
-            traceWithFakeArgumentInfo.record(EXPRESSION_TYPE, fakeArgument, type);
-            traceWithFakeArgumentInfo.record(PROCESSED, fakeArgument);
+            fakeArguments.add(createFakeExpressionOfType(context.expressionTypingServices.getProject(), traceWithFakeArgumentInfo,
+                                                         "fakeArgument" + fakeArguments.size(), type));
         }
         return makeAndResolveFakeCall(receiver, context.replaceBindingTrace(traceWithFakeArgumentInfo), fakeArguments, name).getSecond();
     }
 
+    public static JetExpression createFakeExpressionOfType(
+            @NotNull Project project,
+            @NotNull BindingTrace trace,
+            @NotNull String argumentName,
+            @NotNull JetType argumentType
+    ) {
+        JetExpression fakeExpression = JetPsiFactory.createExpression(project, argumentName);
+        trace.record(EXPRESSION_TYPE, fakeExpression, argumentType);
+        trace.record(PROCESSED, fakeExpression);
+        return fakeExpression;
+    }
+
     @NotNull
     public static OverloadResolutionResults<FunctionDescriptor> resolveFakeCall(
             @NotNull ExpressionTypingContext context,