Fixed KT-5433 J2K: incorrect conversion of method call with vararg

#KT-5433 Fixed

j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt

@@ -137,9 +137,9 @@ class LambdaExpression(val arguments: String?, val block: Block) : Expression()
     }
 }
 
-class StarExpression(val methodCall: MethodCallExpression) : Expression() {
+class StarExpression(val operand: Expression) : Expression() {
     override fun generateCode(builder: CodeBuilder) {
-        builder append "*" append methodCall
+        builder.append("*").appendOperand(this, operand)
     }
 }
 

j2k/src/org/jetbrains/jet/j2k/ast/Util.kt

@@ -37,7 +37,7 @@ fun CodeBuilder.appendOperand(expression: Expression, operand: Expression, paren
 
 private fun Expression.precedence(): Int? {
     return when(this) {
-        is QualifiedExpression, is MethodCallExpression, is ArrayAccessExpression, is PostfixOperator, is BangBangExpression -> 0
+        is QualifiedExpression, is MethodCallExpression, is ArrayAccessExpression, is PostfixOperator, is BangBangExpression, is StarExpression -> 0
 
         is PrefixOperator -> 1
 

j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt

@@ -375,13 +375,18 @@ open class ExpressionVisitor(private val converter: Converter) : JavaElementVisi
             arguments = arguments.drop(1)
         }
         val resolved = expression.resolveMethod()
-        val expectedTypes = if (resolved != null)
-            resolved.getParameterList().getParameters().map { it.getType() }
-        else
-            listOf()
+        val parameters = resolved?.getParameterList()?.getParameters()
+        val expectedTypes = parameters?.map { it.getType() } ?: listOf()
 
         return if (arguments.size == expectedTypes.size())
-            (0..expectedTypes.lastIndex).map { i -> converter.convertExpression(arguments[i], expectedTypes[i]) }
+            (0..arguments.lastIndex).map { i ->
+                val argument = arguments[i]
+                val converted = converter.convertExpression(argument, expectedTypes[i])
+                if (parameters != null && i == arguments.lastIndex && parameters[i].isVarArgs() && argument.getType() is PsiArrayType)
+                    StarExpression(converted).assignNoPrototype()
+                else
+                    converted
+            }
         else
             arguments.map { converter.convertExpression(it) }
     }

j2k/tests/test/org/jetbrains/jet/j2k/test/JavaToKotlinConverterTestGenerated.java

@@ -2035,6 +2035,16 @@ public class JavaToKotlinConverterTestGenerated extends AbstractJavaToKotlinConv
             doTest("j2k/tests/testData/ast/methodCallExpression/simpleCall.java");
         }
         
+        @TestMetadata("vararg1.java")
+        public void testVararg1() throws Exception {
+            doTest("j2k/tests/testData/ast/methodCallExpression/vararg1.java");
+        }
+        
+        @TestMetadata("vararg2.java")
+        public void testVararg2() throws Exception {
+            doTest("j2k/tests/testData/ast/methodCallExpression/vararg2.java");
+        }
+        
     }
     
     @TestMetadata("j2k/tests/testData/ast/misc")

j2k/tests/testData/JavaApi.java

@@ -49,10 +49,14 @@ public enum E {
     A, B, C
 }
 
-class Base {
+public class Base {
     public @Nullable String foo(@Nullable String s) { return s; }
 }
 
-class Derived extends Base {
+public class Derived extends Base {
     public String foo(String s) { return s; }
 }
+
+public class WithVarargConstructor {
+    public WithVarargConstructor(int p, Object... objects) { }
+}

j2k/tests/testData/ast/methodCallExpression/vararg1.java

@@ -0,0 +1,9 @@
+//file
+import java.lang.reflect.Constructor;
+
+class X {
+    static <T> void foo(Constructor<T> constructor, Object[] args1, Object[] args2) throws Exception {
+        constructor.newInstance(args1);
+        constructor.newInstance(args1, args2);
+    }
+}

j2k/tests/testData/ast/methodCallExpression/vararg1.kt

@@ -0,0 +1,11 @@
+import java.lang.reflect.Constructor
+
+class X {
+    class object {
+        throws(javaClass<Exception>())
+        fun <T> foo(constructor: Constructor<T>, args1: Array<Any>, args2: Array<Any>) {
+            constructor.newInstance(*args1)
+            constructor.newInstance(args1, args2)
+        }
+    }
+}

j2k/tests/testData/ast/methodCallExpression/vararg2.java

@@ -0,0 +1,12 @@
+//file
+import javaApi.WithVarargConstructor;
+
+import java.lang.String;
+
+class X {
+    void foo() {
+        WithVarargConstructor o1 = new WithVarargConstructor(1, new Object[]{"a"});
+        WithVarargConstructor o2 = new WithVarargConstructor(2, new Object[]{"a"}, new Object[]{"b"});
+        WithVarargConstructor o3 = new WithVarargConstructor(2, "a");
+    }
+}

j2k/tests/testData/ast/methodCallExpression/vararg2.kt

@@ -0,0 +1,9 @@
+import javaApi.WithVarargConstructor
+
+class X {
+    fun foo() {
+        val o1 = WithVarargConstructor(1, *array<Any>("a"))
+        val o2 = WithVarargConstructor(2, array<Any>("a"), array<Any>("b"))
+        val o3 = WithVarargConstructor(2, "a")
+    }
+}