Inline ExpressionCodegen#pushMethodArguments, drop "skipLast" hack

compiler/backend/src/org/jetbrains/jet/codegen/CallBasedArgumentGenerator.java

@@ -34,25 +34,24 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator {
     private final CallGenerator callGenerator;
     private final List<ValueParameterDescriptor> valueParameters;
     private final List<Type> valueParameterTypes;
-    private final boolean skipLast;
 
     public CallBasedArgumentGenerator(
             @NotNull ExpressionCodegen codegen,
             @NotNull CallGenerator callGenerator,
             @NotNull List<ValueParameterDescriptor> valueParameters,
-            @NotNull List<Type> valueParameterTypes,
+            @NotNull List<Type> valueParameterTypes
-            boolean skipLast
     ) {
         this.codegen = codegen;
         this.callGenerator = callGenerator;
         this.valueParameters = valueParameters;
         this.valueParameterTypes = valueParameterTypes;
-        this.skipLast = skipLast;
+
+        assert valueParameters.size() == valueParameterTypes.size() :
+                "Value parameters and their types mismatch in sizes: " + valueParameters.size() + " != " + valueParameterTypes.size();
     }
 
     @Override
     protected void generateExpression(int i, @NotNull ExpressionValueArgument argument) {
-        if (shouldSkip(i)) return;
         ValueParameterDescriptor parameter = valueParameters.get(i);
         Type type = valueParameterTypes.get(i);
         ValueArgument valueArgument = argument.getValueArgument();
@@ -64,7 +63,6 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator {
 
     @Override
     protected void generateDefault(int i, @NotNull DefaultValueArgument argument) {
-        if (shouldSkip(i)) return;
         ValueParameterDescriptor parameter = valueParameters.get(i);
         Type type = valueParameterTypes.get(i);
         pushDefaultValueOnStack(type, codegen.v);
@@ -73,14 +71,9 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator {
 
     @Override
     protected void generateVararg(int i, @NotNull VarargValueArgument argument) {
-        if (shouldSkip(i)) return;
         ValueParameterDescriptor parameter = valueParameters.get(i);
         Type type = valueParameterTypes.get(i);
         codegen.genVarargs(argument, parameter.getType());
         callGenerator.afterParameterPut(type, null, parameter);
     }
-
-    private boolean shouldSkip(int i) {
-        return skipLast && i == valueParameters.size() - 1;
-    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -1342,8 +1342,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             assert valueArguments != null : "Failed to arrange value arguments by index: " + superConstructor;
             ArgumentGenerator argumentGenerator =
                     new CallBasedArgumentGenerator(this, defaultCallGenerator, superConstructor.getValueParameters(),
-                                                   typeMapper.mapToCallableMethod(superConstructor).getValueParameterTypes(),
+                                                   typeMapper.mapToCallableMethod(superConstructor).getValueParameterTypes());
-                                                   /* skipLast = */ false);
             argumentGenerator.generate(valueArguments);
         }
 
@@ -2131,9 +2130,19 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                 "Tail recursive method couldn't be inlined " + descriptor;
 
         ArgumentGenerator argumentGenerator = new CallBasedArgumentGenerator(this, callGenerator, descriptor.getValueParameters(),
-                                                                             callableMethod.getValueParameterTypes(),
+                                                                             callableMethod.getValueParameterTypes());
-                                                                             /* skipLast = */ false);
+
-        int mask = pushMethodArguments(receiver, resolvedCall, callableMethod, callGenerator, argumentGenerator);
+        if (!(descriptor instanceof ConstructorDescriptor)) { // otherwise already
+            receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
+            receiver.put(receiver.type, v);
+        }
+
+        callGenerator.putHiddenParams();
+
+        List<ResolvedValueArgument> valueArguments = resolvedCall.getValueArgumentsByIndex();
+        assert valueArguments != null : "Failed to arrange value arguments by index: " + descriptor;
+
+        int mask = argumentGenerator.generate(valueArguments);
 
         if (tailRecursionCodegen.isTailRecursion(resolvedCall)) {
             tailRecursionCodegen.generateTailRecursion(resolvedCall);
@@ -2316,28 +2325,6 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         return false;
     }
 
-    private int pushMethodArguments(
-            @Nullable StackValue receiver,
-            @NotNull ResolvedCall<?> resolvedCall,
-            @NotNull CallableMethod callableMethod,
-            @NotNull CallGenerator callGenerator,
-            @NotNull ArgumentGenerator argumentGenerator
-    ) {
-        CallableDescriptor descriptor = resolvedCall.getResultingDescriptor();
-
-        if (!(descriptor instanceof ConstructorDescriptor)) { // otherwise already
-            receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
-            receiver.put(receiver.type, v);
-        }
-
-        callGenerator.putHiddenParams();
-
-        List<ResolvedValueArgument> valueArguments = resolvedCall.getValueArgumentsByIndex();
-        assert valueArguments != null : "Failed to arrange value arguments by index: " + descriptor;
-
-        return argumentGenerator.generate(valueArguments);
-    }
-
     public void genVarargs(@NotNull VarargValueArgument valueArgument, @NotNull JetType outType) {
         Type type = asmType(outType);
         assert type.getSort() == Type.ARRAY;
@@ -3371,9 +3358,22 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                 ArgumentGenerator argumentGenerator =
                         new CallBasedArgumentGenerator(this, defaultCallGenerator,
                                                        resolvedCall.getResultingDescriptor().getValueParameters(),
-                                                       callableMethod.getValueParameterTypes(),
+                                                       callableMethod.getValueParameterTypes());
-                                                       /* skipLast = */ !isGetter);
+
-                pushMethodArguments(receiver, resolvedCall, callableMethod, defaultCallGenerator, argumentGenerator);
+                receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
+                receiver.put(receiver.type, v);
+
+                List<ResolvedValueArgument> valueArguments = resolvedCall.getValueArgumentsByIndex();
+                assert valueArguments != null : "Failed to arrange value arguments by index: " + operationDescriptor;
+
+                if (!isGetter) {
+                    assert valueArguments.size() >= 2 : "Setter call should have at least 2 arguments: " + operationDescriptor;
+
+                    // Skip generation of the right hand side of an indexed assignment, which is the last value argument
+                    valueArguments.remove(valueArguments.size() - 1);
+                }
+
+                argumentGenerator.generate(valueArguments);
             }
             else {
                 gen(array, arrayType); // intrinsic method