diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
index aaf15bb8415..6740866e98d 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
@@ -2341,47 +2341,44 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         }
         List<ValueParameterDescriptor> valueParameters = fd.getValueParameters();
 
-        if (valueParameters.size() != valueArguments.size()) {
-            throw new IllegalStateException("Parameters and arguments size mismatch: " + valueParameters.size() + " != " + valueArguments.size());
+        int n = valueParameters.size();
+        if (n != valueArguments.size()) {
+            throw new IllegalStateException("Parameters and arguments size mismatch: " + n + " != " + valueArguments.size());
         }
 
         int mask = 0;
 
-        for (Iterator<ValueParameterDescriptor> iterator = valueParameters.iterator(); iterator.hasNext(); ) {
-            ValueParameterDescriptor valueParameter = iterator.next();
-            if (skipLast && !iterator.hasNext()) {
-                continue;
-            }
+        for (int i = 0; i < n; i++) {
+            if (skipLast && i == n - 1) break;
 
-            ResolvedValueArgument resolvedValueArgument = valueArguments.get(valueParameter.getIndex());
-            Type parameterType = valueParameterTypes.get(valueParameter.getIndex());
-            if (resolvedValueArgument instanceof ExpressionValueArgument) {
-                ValueArgument valueArgument = ((ExpressionValueArgument) resolvedValueArgument).getValueArgument();
+            ValueParameterDescriptor valueParameter = valueParameters.get(i);
+            ResolvedValueArgument argument = valueArguments.get(i);
+            Type parameterType = valueParameterTypes.get(i);
+            if (argument instanceof ExpressionValueArgument) {
+                ValueArgument valueArgument = ((ExpressionValueArgument) argument).getValueArgument();
                 assert valueArgument != null;
                 JetExpression argumentExpression = valueArgument.getArgumentExpression();
                 assert argumentExpression != null : valueArgument.asElement().getText();
-
                 callGenerator.genValueAndPut(valueParameter, argumentExpression, parameterType);
-            } else if (resolvedValueArgument instanceof DefaultValueArgument) {
+            }
+            else if (argument instanceof DefaultValueArgument) {
                 pushDefaultValueOnStack(parameterType, v);
-                mask |= (1 << valueParameter.getIndex());
+                mask |= 1 << i;
                 callGenerator.afterParameterPut(parameterType, null, valueParameter);
             }
-            else if (resolvedValueArgument instanceof VarargValueArgument) {
-                VarargValueArgument valueArgument = (VarargValueArgument) resolvedValueArgument;
-                genVarargs(valueParameter, valueArgument);
+            else if (argument instanceof VarargValueArgument) {
+                genVarargs((VarargValueArgument) argument, valueParameter.getType());
                 callGenerator.afterParameterPut(parameterType, null, valueParameter);
             }
             else {
-                throw new UnsupportedOperationException();
+                throw new UnsupportedOperationException("Unsupported value argument: " + argument);
             }
         }
+
         return mask;
     }
 
-    public void genVarargs(ValueParameterDescriptor valueParameterDescriptor, VarargValueArgument valueArgument) {
-        JetType outType = valueParameterDescriptor.getType();
-
+    public void genVarargs(@NotNull VarargValueArgument valueArgument, @NotNull JetType outType) {
         Type type = asmType(outType);
         assert type.getSort() == Type.ARRAY;
         Type elementType = correctElementType(type);
diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java
index 374a9a01663..635cf69dd96 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java
+++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java
@@ -24,7 +24,6 @@ import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.model.VarargValueArgument;
@@ -34,6 +33,8 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import java.util.List;
 import java.util.Map;
 
+import static org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage.getResolvedCallWithAssert;
+
 public class JavaClassArray extends IntrinsicMethod {
     @NotNull
     @Override
@@ -45,9 +46,10 @@ public class JavaClassArray extends IntrinsicMethod {
             @Nullable List<JetExpression> arguments,
             StackValue receiver
     ) {
-        ResolvedCall<?> call = BindingContextUtilPackage.getResolvedCallWithAssert((JetElement) element, codegen.getBindingContext());
-        Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> next = call.getValueArguments().entrySet().iterator().next();
-        codegen.genVarargs(next.getKey(), (VarargValueArgument) next.getValue());
+        assert element != null : "Element should not be null";
+        ResolvedCall<?> resolvedCall = getResolvedCallWithAssert((JetElement) element, codegen.getBindingContext());
+        Map.Entry<ValueParameterDescriptor, ResolvedValueArgument> argument = resolvedCall.getValueArguments().entrySet().iterator().next();
+        codegen.genVarargs((VarargValueArgument) argument.getValue(), argument.getKey().getType());
         return returnType;
     }
 }