diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java index e941b94f3bf..801b579885e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java +++ b/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? with Array 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 with Array? - return new VarargCheckResult( - TypeUtils.makeNullable(KotlinBuiltIns.getInstance().getArrayType(Variance.OUT_VARIANCE, originalVarargElementType)), - false); + return new VarargCheckResult(TypeUtils.makeNullable(getArrayType(originalVarargElementType, Variance.OUT_VARIANCE)), 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; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java index 371c2e1bb73..75e97187252 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java +++ b/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() { diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java new file mode 100644 index 00000000000..0892535cfd7 --- /dev/null +++ b/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); + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt new file mode 100644 index 00000000000..44622b7f3d6 --- /dev/null +++ b/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?) + } + + public trait Sub: Super { + override fun foo(p0: Array?) + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.txt new file mode 100644 index 00000000000..ea9d28c72fa --- /dev/null +++ b/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?): jet.Tuple0 + } + public abstract trait test.InheritNotVarargInteger.Super : java.lang.Object { + public abstract fun foo(/*0*/ p0: jet.Array?): jet.Tuple0 + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java new file mode 100644 index 00000000000..057b2d948f9 --- /dev/null +++ b/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); + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt new file mode 100644 index 00000000000..0852029c602 --- /dev/null +++ b/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?) + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.txt new file mode 100644 index 00000000000..2a98737e8de --- /dev/null +++ b/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 + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.java new file mode 100644 index 00000000000..aadd4265d56 --- /dev/null +++ b/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); + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.kt new file mode 100644 index 00000000000..7d04cf3b374 --- /dev/null +++ b/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?) + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.txt new file mode 100644 index 00000000000..dd40ff56124 --- /dev/null +++ b/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.Tuple0 + } + public abstract trait test.InheritVarargInteger.Super : java.lang.Object { + public abstract fun foo(/*0*/ vararg p0: jet.Int? /*jet.Array*/): jet.Tuple0 + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java new file mode 100644 index 00000000000..a1708aa507e --- /dev/null +++ b/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); + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt new file mode 100644 index 00000000000..046d226ca07 --- /dev/null +++ b/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) + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.txt b/compiler/testData/loadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.txt new file mode 100644 index 00000000000..6c27ef86199 --- /dev/null +++ b/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 + } +} diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java index 1e36326e7a3..e2fd602cdce 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java +++ b/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"); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index f390c7e6e84..62173b69130 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/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");