Processing vararg flag of parameter for primitives and wrappers.

#KT-2776 fixed

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java

@@ -240,19 +240,17 @@ public class SignaturesPropagationData {
         }
 
         if (someSupersVararg && originalVarargElementType == null) {
-            assert KotlinBuiltIns.getInstance().isArray(originalType);
+            assert isArrayType(originalType);
 
             // convert to vararg; replace Array<out Foo>? with Array<Foo>
             JetType varargElementType = KotlinBuiltIns.getInstance().getArrayElementType(originalType);
-            return new VarargCheckResult(KotlinBuiltIns.getInstance().getArrayType(varargElementType), true);
+            return new VarargCheckResult(getArrayType(varargElementType, Variance.INVARIANT), true);
         }
         else if (someSupersNotVararg && originalVarargElementType != null) {
-            assert KotlinBuiltIns.getInstance().isArray(originalType);
+            assert isArrayType(originalType);
 
             // convert to non-vararg; replace Array<Foo> with Array<out Foo>?
-            return new VarargCheckResult(
+            return new VarargCheckResult(TypeUtils.makeNullable(getArrayType(originalVarargElementType, Variance.OUT_VARIANCE)), false);
-                    TypeUtils.makeNullable(KotlinBuiltIns.getInstance().getArrayType(Variance.OUT_VARIANCE, originalVarargElementType)),
-                    false);
         }
 
         return new VarargCheckResult(originalType, originalVarargElementType != null);
@@ -521,6 +519,23 @@ public class SignaturesPropagationData {
         return classifier;
     }
 
+    private static boolean isArrayType(@NotNull JetType type) {
+        KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
+        return builtIns.isArray(type) || builtIns.isPrimitiveArray(type);
+    }
+
+    @NotNull
+    private static JetType getArrayType(@NotNull JetType elementType, @NotNull Variance projectionKind) {
+        KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance();
+        JetType primitiveArrayType = builtIns.getPrimitiveArrayJetTypeByPrimitiveJetType(elementType);
+        if (primitiveArrayType != null) {
+            return primitiveArrayType;
+        }
+        else {
+            return builtIns.getArrayType(projectionKind, elementType);
+        }
+    }
+
     private static class VarargCheckResult {
         public final JetType parameterType;
         public final boolean isVararg;

compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java

@@ -726,14 +726,13 @@ public class KotlinBuiltIns {
 
     @NotNull
     public JetType getArrayElementType(@NotNull JetType arrayType) {
-        // make non-null?
         if (arrayType.getConstructor().getDeclarationDescriptor() == getArray()) {
             if (arrayType.getArguments().size() != 1) {
                 throw new IllegalStateException();
             }
             return arrayType.getArguments().get(0).getType();
         }
-        JetType primitiveType = jetArrayTypeToPrimitiveJetType.get(arrayType);
+        JetType primitiveType = jetArrayTypeToPrimitiveJetType.get(TypeUtils.makeNotNullable(arrayType));
         if (primitiveType == null) {
             throw new IllegalStateException("not array: " + arrayType);
         }
@@ -823,6 +822,10 @@ public class KotlinBuiltIns {
         return getArray().equals(type.getConstructor().getDeclarationDescriptor());
     }
 
+    public boolean isPrimitiveArray(@NotNull JetType type) {
+        return jetArrayTypeToPrimitiveJetType.containsKey(TypeUtils.makeNotNullable(type));
+    }
+
     // Functions
 
     public int getFunctionTraitCount() {

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
+    }
+}

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java

@@ -471,11 +471,21 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVararg.java");
                 }
                 
+                @TestMetadata("InheritNotVarargInteger.java")
+                public void testInheritNotVarargInteger() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java");
+                }
+                
                 @TestMetadata("InheritNotVarargNotNull.java")
                 public void testInheritNotVarargNotNull() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.java");
                 }
                 
+                @TestMetadata("InheritNotVarargPrimitive.java")
+                public void testInheritNotVarargPrimitive() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java");
+                }
+                
                 @TestMetadata("InheritNullability.java")
                 public void testInheritNullability() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNullability.java");
@@ -496,11 +506,21 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVararg.java");
                 }
                 
+                @TestMetadata("InheritVarargInteger.java")
+                public void testInheritVarargInteger() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.java");
+                }
+                
                 @TestMetadata("InheritVarargNotNull.java")
                 public void testInheritVarargNotNull() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.java");
                 }
                 
+                @TestMetadata("InheritVarargPrimitive.java")
+                public void testInheritVarargPrimitive() throws Exception {
+                    doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java");
+                }
+                
                 @TestMetadata("MutableToReadOnly.java")
                 public void testMutableToReadOnly() throws Exception {
                     doTest("compiler/testData/loadJava/kotlinSignature/propagation/parameter/MutableToReadOnly.java");

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java

@@ -1361,11 +1361,21 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVararg.kt");
                     }
                     
+                    @TestMetadata("InheritNotVarargInteger.kt")
+                    public void testInheritNotVarargInteger() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt");
+                    }
+                    
                     @TestMetadata("InheritNotVarargNotNull.kt")
                     public void testInheritNotVarargNotNull() throws Exception {
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt");
                     }
                     
+                    @TestMetadata("InheritNotVarargPrimitive.kt")
+                    public void testInheritNotVarargPrimitive() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt");
+                    }
+                    
                     @TestMetadata("InheritNullability.kt")
                     public void testInheritNullability() throws Exception {
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNullability.kt");
@@ -1386,11 +1396,21 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVararg.kt");
                     }
                     
+                    @TestMetadata("InheritVarargInteger.kt")
+                    public void testInheritVarargInteger() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.kt");
+                    }
+                    
                     @TestMetadata("InheritVarargNotNull.kt")
                     public void testInheritVarargNotNull() throws Exception {
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt");
                     }
                     
+                    @TestMetadata("InheritVarargPrimitive.kt")
+                    public void testInheritVarargPrimitive() throws Exception {
+                        doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt");
+                    }
+                    
                     @TestMetadata("MutableToReadOnly.kt")
                     public void testMutableToReadOnly() throws Exception {
                         doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/parameter/MutableToReadOnly.kt");