Processing vararg flag of parameter for primitives and wrappers.

#KT-2776 fixed

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritNotVarargInteger {
+
+    public interface Super {
+        void foo(Integer[] p);
+    }
+
+    public interface Sub extends Super {
+        void foo(Integer... p);
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritNotVarargInteger: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: Array<out Int?>?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: Array<out Int?>?)
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt

@@ -0,0 +1,10 @@
+namespace test
+
+public abstract trait test.InheritNotVarargInteger : java.lang.Object {
+    public abstract trait test.InheritNotVarargInteger.Sub : test.InheritNotVarargInteger.Super {
+        public abstract override /*1*/ fun foo(/*0*/ p0: jet.Array<out jet.Int?>?): jet.Tuple0
+    }
+    public abstract trait test.InheritNotVarargInteger.Super : java.lang.Object {
+        public abstract fun foo(/*0*/ p0: jet.Array<out jet.Int?>?): jet.Tuple0
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritNotVarargPrimitive {
+
+    public interface Super {
+        void foo(int[] p);
+    }
+
+    public interface Sub extends Super {
+        void foo(int... p);
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritNotVarargPrimitive: Object {
+
+    public trait Super: Object {
+        public fun foo(p0: IntArray?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(p0: IntArray?)
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.txt

@@ -0,0 +1,10 @@
+namespace test
+
+public abstract trait test.InheritNotVarargPrimitive : java.lang.Object {
+    public abstract trait test.InheritNotVarargPrimitive.Sub : test.InheritNotVarargPrimitive.Super {
+        public abstract override /*1*/ fun foo(/*0*/ p0: jet.IntArray?): jet.Tuple0
+    }
+    public abstract trait test.InheritNotVarargPrimitive.Super : java.lang.Object {
+        public abstract fun foo(/*0*/ p0: jet.IntArray?): jet.Tuple0
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.java

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritVarargInteger {
+
+    public interface Super {
+        void foo(Integer... p);
+    }
+
+    public interface Sub extends Super {
+        void foo(Integer[] p);
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.kt

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritVarargInteger: Object {
+
+    public trait Super: Object {
+        public fun foo(vararg p0: Int?)
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: Int?)
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.txt

@@ -0,0 +1,10 @@
+namespace test
+
+public abstract trait test.InheritVarargInteger : java.lang.Object {
+    public abstract trait test.InheritVarargInteger.Sub : test.InheritVarargInteger.Super {
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0: jet.Int? /*jet.Array<jet.Int?>*/): jet.Tuple0
+    }
+    public abstract trait test.InheritVarargInteger.Super : java.lang.Object {
+        public abstract fun foo(/*0*/ vararg p0: jet.Int? /*jet.Array<jet.Int?>*/): jet.Tuple0
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java

@@ -0,0 +1,12 @@
+package test;
+
+public interface InheritVarargPrimitive {
+
+    public interface Super {
+        void foo(int... p);
+    }
+
+    public interface Sub extends Super {
+        void foo(int[] p);
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt

@@ -0,0 +1,12 @@
+package test
+
+public trait InheritVarargPrimitive: Object {
+
+    public trait Super: Object {
+        public fun foo(vararg p0: Int)
+    }
+
+    public trait Sub: Super {
+        override fun foo(vararg p0: Int)
+    }
+}

compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.txt

@@ -0,0 +1,10 @@
+namespace test
+
+public abstract trait test.InheritVarargPrimitive : java.lang.Object {
+    public abstract trait test.InheritVarargPrimitive.Sub : test.InheritVarargPrimitive.Super {
+        public abstract override /*1*/ fun foo(/*0*/ vararg p0: jet.Int /*jet.IntArray*/): jet.Tuple0
+    }
+    public abstract trait test.InheritVarargPrimitive.Super : java.lang.Object {
+        public abstract fun foo(/*0*/ vararg p0: jet.Int /*jet.IntArray*/): jet.Tuple0
+    }
+}