Supported propagation of vararg mark.

#KT-2776 in progress

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface InheritNotVarargNotNull {
+
+    public interface Super {
+        @KotlinSignature("fun foo(p: Array<out String>)")
+        void foo(String[] p);
+    }
+
+    public interface Sub extends Super {
+        void foo(String... p);
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+package test;
+
+import jet.runtime.typeinfo.KotlinSignature;
+
+public interface InheritVarargNotNull {
+
+    public interface Super {
+        @KotlinSignature("fun foo(vararg p: String)")
+        void foo(String... p);
+    }
+
+    public interface Sub extends Super {
+        void foo(String[] p);
+    }
+}

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

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

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

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