From cda953942dae4080d4cb1aef1d495cbbb1b0b658 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 20 Nov 2012 20:39:18 +0400 Subject: [PATCH] Added @ExpectLoadErrors annotations to test data. Also, fixed syntax error in AddNullabilitySameJavaType. --- .../error/AddingNullability.java | 2 ++ .../error/ExplicitFieldGettersAndSetters.java | 4 ++-- .../error/ExtraUpperBound.java | 2 ++ .../error/MissingUpperBound.java | 2 ++ .../kotlinSignature/error/NoFieldTypeRef.java | 4 ++-- .../error/NotVarargReplacedWithVararg.java | 22 ++----------------- .../error/ReturnTypeMissing.java | 20 ++--------------- .../kotlinSignature/error/SyntaxError.java | 2 ++ .../error/SyntaxErrorInFieldAnnotation.java | 4 ++-- .../error/VarargReplacedWithNotVararg.java | 6 ++--- .../error/WrongFieldInitializer.java | 4 ++-- .../error/WrongFieldMutability.java | 5 +++-- .../kotlinSignature/error/WrongFieldName.java | 4 ++-- .../error/WrongMethodName.java | 2 ++ .../error/WrongReturnTypeStructure.java | 3 ++- .../kotlinSignature/error/WrongTypeName1.java | 3 ++- .../kotlinSignature/error/WrongTypeName2.java | 3 ++- .../kotlinSignature/error/WrongTypeName3.java | 3 ++- .../WrongTypeParameterBoundStructure1.java | 5 ++--- .../WrongTypeParameterBoundStructure2.java | 5 ++--- .../error/WrongTypeParametersCount.java | 5 ++--- .../error/WrongTypeVariance.java | 5 ++--- .../error/WrongValueParameterStructure1.java | 3 ++- .../error/WrongValueParameterStructure2.java | 3 ++- .../error/WrongValueParametersCount.java | 2 ++ .../return/AddNullabilityJavaSubtype.java | 2 ++ .../AddNullabilitySameGenericType1.java | 2 ++ .../AddNullabilitySameGenericType2.java | 2 ++ .../return/AddNullabilitySameJavaType.java | 4 +++- ...uperclassesConflictingProjectionKinds.java | 2 ++ ...oSuperclassesInconsistentGenericTypes.java | 2 ++ 31 files changed, 64 insertions(+), 73 deletions(-) diff --git a/compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java b/compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java index d815af6199b..fa42b8e090e 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java +++ b/compiler/testData/loadJava/kotlinSignature/error/AddingNullability.java @@ -1,8 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class AddingNullability { + @ExpectLoadError("Auto type 'jet.Int' is not-null, while type in alternative signature is nullable: 'Int?'") @KotlinSignature("fun foo() : Int?") public int foo() { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java b/compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java index 318731787ec..bbbf35217b0 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java +++ b/compiler/testData/loadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.java @@ -1,10 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; - -import java.lang.String; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class ExplicitFieldGettersAndSetters { + @ExpectLoadError("Field annotation for shouldn't have getters and setters") @KotlinSignature("var foo: String get() { return \"hello\" }") public String foo; } diff --git a/compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java b/compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java index d9155efb6a0..e059a422aac 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java +++ b/compiler/testData/loadJava/kotlinSignature/error/ExtraUpperBound.java @@ -1,8 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class ExtraUpperBound { + @ExpectLoadError("Extra upper bound #1 for type parameter A") @KotlinSignature("fun foo() : String where A : Cloneable") public String foo() { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java b/compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java index a32c5b2a4f4..e95bdc028e9 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java +++ b/compiler/testData/loadJava/kotlinSignature/error/MissingUpperBound.java @@ -1,8 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class MissingUpperBound { + @ExpectLoadError("Upper bound #1 for type parameter A is missing") @KotlinSignature("fun foo() : String") public String foo() { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/NoFieldTypeRef.java b/compiler/testData/loadJava/kotlinSignature/error/NoFieldTypeRef.java index aa6ee47bf5e..5743c0481f5 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/NoFieldTypeRef.java +++ b/compiler/testData/loadJava/kotlinSignature/error/NoFieldTypeRef.java @@ -1,10 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; - -import java.lang.String; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class NoFieldTypeRef { + @ExpectLoadError("Field annotation for shouldn't have type reference") @KotlinSignature("var foo") public String foo; } diff --git a/compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java b/compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java index 0e835fbd860..7ef352ee0fb 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java +++ b/compiler/testData/loadJava/kotlinSignature/error/NotVarargReplacedWithVararg.java @@ -1,30 +1,12 @@ -/* - * Copyright 2010-2012 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - package test; -import java.lang.String; -import java.lang.UnsupportedOperationException; import java.util.*; -import java.util.BitSet; -import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class NotVarargReplacedWithVararg { + @ExpectLoadError("Parameter in method signature is not vararg, but in alternative signature it is vararg") @KotlinSignature("fun foo(vararg s : String)") public void foo(String s) { } diff --git a/compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java b/compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java index 35827409244..0725f82ee1b 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java +++ b/compiler/testData/loadJava/kotlinSignature/error/ReturnTypeMissing.java @@ -1,26 +1,10 @@ -/* - * Copyright 2010-2012 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - package test; import jet.runtime.typeinfo.KotlinSignature; - -import java.lang.String; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class ReturnTypeMissing { + @ExpectLoadError("Return type in alternative signature is missing, while in real signature it is 'jet.Int'") @KotlinSignature("fun foo(a : String)") public int foo(String a) { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java b/compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java index 21c805204fb..d5a1e660077 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java +++ b/compiler/testData/loadJava/kotlinSignature/error/SyntaxError.java @@ -1,8 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class SyntaxError { + @ExpectLoadError("Alternative signature has 2 syntax errors, first is at 8: Expecting a parameter declaration") @KotlinSignature("fun foo(,) : Int") public Integer foo() { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java b/compiler/testData/loadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java index e632e0bf4d6..b0e0bec2711 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java +++ b/compiler/testData/loadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.java @@ -1,10 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; - -import java.lang.String; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class SyntaxErrorInFieldAnnotation { + @ExpectLoadError("Alternative signature has syntax error at 10: Type expected") @KotlinSignature("var foo : ") public String foo; } diff --git a/compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java b/compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java index d0ce03358e0..98a5c5f331a 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java +++ b/compiler/testData/loadJava/kotlinSignature/error/VarargReplacedWithNotVararg.java @@ -1,14 +1,12 @@ package test; -import java.lang.String; -import java.lang.UnsupportedOperationException; import java.util.*; -import java.util.BitSet; -import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class VarargReplacedWithNotVararg { + @ExpectLoadError("Parameter in method signature is vararg, but in alternative signature it is not") @KotlinSignature("fun foo(s : String)") public void foo(String... s) { } diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldInitializer.java b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldInitializer.java index 45f4ea8fdb1..fb4f1671e75 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldInitializer.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldInitializer.java @@ -1,10 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; - -import java.lang.String; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongFieldInitializer { + @ExpectLoadError("Default value is not expected in annotation for field") @KotlinSignature("var foo : String = \"Test\"") public String foo; } diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldMutability.java b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldMutability.java index 812d623c724..7d1b4558734 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldMutability.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldMutability.java @@ -1,13 +1,14 @@ package test; import jet.runtime.typeinfo.KotlinSignature; - -import java.lang.String; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongFieldMutability { + @ExpectLoadError("Wrong mutability in annotation for field") @KotlinSignature("val fooNotFinal : String") public String fooNotFinal; + @ExpectLoadError("Wrong mutability in annotation for field") @KotlinSignature("var fooFinal : String") public final String fooFinal = "Test"; } diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldName.java b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldName.java index ff96c6906c7..8a4f8639f9b 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongFieldName.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongFieldName.java @@ -1,10 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; - -import java.lang.String; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongFieldName { + @ExpectLoadError("Field name mismatch, original: foo, alternative: bar") @KotlinSignature("var bar: String") public String foo; } diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java b/compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java index 52aadd8a7e3..8ef49420549 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongMethodName.java @@ -1,8 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongMethodName { + @ExpectLoadError("Function names mismatch, original: foo, alternative: bar") @KotlinSignature("fun bar() : String") public String foo() { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java b/compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java index 484ce0e42a0..24bdd2adf25 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongReturnTypeStructure.java @@ -1,10 +1,11 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongReturnTypeStructure { + @ExpectLoadError("'jet.String?' type in method signature has 0 type arguments, while 'String' in alternative signature has 1 of them") @KotlinSignature("fun foo(a : String, b : List?>) : String?") public String foo(String a, List> b) { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java index af4af2283b7..c0516ad8e6c 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName1.java @@ -1,10 +1,11 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongTypeName1 { + @ExpectLoadError("Alternative signature type mismatch, expected: jet.Tuple0, actual: jet.String") @KotlinSignature("fun foo(a : String) : Unit") public String foo(String a) { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java index 6f5fc46618f..b15eaf38ed3 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName2.java @@ -1,10 +1,11 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongTypeName2 { + @ExpectLoadError("Alternative signature type mismatch, expected: Something.String, actual: jet.String") @KotlinSignature("fun foo(a : Something.String) : String") public String foo(String a) { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java index d2b90c49e53..ed711c221f7 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeName3.java @@ -1,10 +1,11 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongTypeName3 { + @ExpectLoadError("Alternative signature type mismatch, expected: List, actual: jet.String") @KotlinSignature("fun foo(a : String) : List") public String foo(String a) { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java index 873d96e9154..2493b5086f9 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java @@ -1,13 +1,12 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; -import java.util.BitSet; -import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongTypeParameterBoundStructure1 { + @ExpectLoadError("'java.lang.Runnable?' type in method signature has 0 type arguments, while 'Runnable' in alternative signature has 1 of them") @KotlinSignature("fun > foo(a : A, b : List, c: List) where B : List") public > void foo(A a, List b, List list) { } diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java index 7f0b443bcf5..9120dd812be 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.java @@ -1,13 +1,12 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; -import java.util.BitSet; -import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongTypeParameterBoundStructure2 { + @ExpectLoadError("'jet.List?' type in method signature has 1 type arguments, while 'List' in alternative signature has 0 of them") @KotlinSignature("fun foo(a : A, b : List, c: List) where B : List") public > void foo(A a, List b, List list) { } diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java index ade3f30faf5..64a859c06ae 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeParametersCount.java @@ -1,13 +1,12 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; -import java.util.BitSet; -import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongTypeParametersCount { + @ExpectLoadError("Method signature has 2 type parameters, but alternative signature has 3") @KotlinSignature("fun foo(a : A, b : List)") public void foo(A a, List b) { } diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java index c0d78a9e48f..4b4aca1655a 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongTypeVariance.java @@ -1,13 +1,12 @@ package test; -import java.lang.Number; -import java.lang.UnsupportedOperationException; import java.util.*; -import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongTypeVariance { + @ExpectLoadError("Variance mismatch, actual: in, in alternative signature: ") @KotlinSignature("fun copy(a : List, b : List) : MutableList") public List copy(List from, List to) { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java index 89bc4c33557..7978adf6055 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure1.java @@ -1,10 +1,11 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongValueParameterStructure1 { + @ExpectLoadError("'jet.String?' type in method signature has 0 type arguments, while 'String' in alternative signature has 1 of them") @KotlinSignature("fun foo(a : String, b : List?>) : String") public String foo(String a, List> b) { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java index fd15f964345..40b9f5a4fcb 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParameterStructure2.java @@ -1,10 +1,11 @@ package test; -import java.lang.UnsupportedOperationException; import java.util.*; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongValueParameterStructure2 { + @ExpectLoadError("'jet.Map.Entry?' type in method signature has 2 type arguments, while 'Map.Entry' in alternative signature has 1 of them") @KotlinSignature("fun foo(a : String, b : List?>) : String") public String foo(String a, List> b) { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java index 3b4b3e9fd74..641ce0965b6 100644 --- a/compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java +++ b/compiler/testData/loadJava/kotlinSignature/error/WrongValueParametersCount.java @@ -1,8 +1,10 @@ package test; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public class WrongValueParametersCount { + @ExpectLoadError("Method signature has 0 value parameters, but alternative signature has 1") @KotlinSignature("fun foo(a : Int) : Int") public Integer foo() { throw new UnsupportedOperationException(); diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java index 7db8113091b..c239fd84fbb 100644 --- a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java @@ -2,6 +2,7 @@ package test; import org.jetbrains.annotations.NotNull; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public interface AddNullabilityJavaSubtype { @@ -11,6 +12,7 @@ public interface AddNullabilityJavaSubtype { } public interface Sub extends Super { + @ExpectLoadError("Alternative signature has 2 syntax errors, first is at 10: Expecting '(") @KotlinSignature("fun String? foo()") String foo(); } diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java index 70441f2b920..0ea9be382a8 100644 --- a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java @@ -3,6 +3,7 @@ package test; import org.jetbrains.annotations.NotNull; import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public interface AddNullabilitySameGenericType1 { @@ -12,6 +13,7 @@ public interface AddNullabilitySameGenericType1 { } public interface Sub extends Super { + @ExpectLoadError("Auto type 'jet.String' is not-null, while type in alternative signature is nullable: 'String?'") @KotlinSignature("fun foo(): MutableList") List foo(); } diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java index e5faf33a7e1..dcf7c92d530 100644 --- a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java @@ -3,6 +3,7 @@ package test; import org.jetbrains.annotations.NotNull; import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public interface AddNullabilitySameGenericType2 { @@ -12,6 +13,7 @@ public interface AddNullabilitySameGenericType2 { } public interface Sub extends Super { + @ExpectLoadError("Auto type 'jet.MutableList' is not-null, while type in alternative signature is nullable: 'MutableList?'") @KotlinSignature("fun foo(): MutableList?") List foo(); } diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java index fd4f25d9cb8..06fea01d8d3 100644 --- a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java @@ -3,6 +3,7 @@ package test; import org.jetbrains.annotations.NotNull; import java.lang.CharSequence; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public interface AddNullabilitySameJavaType { @@ -12,7 +13,8 @@ public interface AddNullabilitySameJavaType { } public interface Sub extends Super { - @KotlinSignature("fun CharSequence? foo()") + @ExpectLoadError("Auto type 'jet.CharSequence' is not-null, while type in alternative signature is nullable: 'CharSequence?'") + @KotlinSignature("fun foo(): CharSequence?") CharSequence foo(); } } \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java index c0bbc51a85d..1bc38fba2a7 100644 --- a/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java @@ -2,6 +2,7 @@ package test; import org.jetbrains.annotations.NotNull; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; import java.util.*; @@ -18,6 +19,7 @@ public interface TwoSuperclassesConflictingProjectionKinds { } public interface Sub extends Super1, Super2 { + @ExpectLoadError("Incompatible projection kinds in type arguments of super methods' return types: [CharSequence, out CharSequence]") public Collection foo(); } } diff --git a/compiler/testData/loadJavaCustom/kotlinSignature/TwoSuperclassesInconsistentGenericTypes.java b/compiler/testData/loadJavaCustom/kotlinSignature/TwoSuperclassesInconsistentGenericTypes.java index fb546563f87..ab9d77ac1b7 100644 --- a/compiler/testData/loadJavaCustom/kotlinSignature/TwoSuperclassesInconsistentGenericTypes.java +++ b/compiler/testData/loadJavaCustom/kotlinSignature/TwoSuperclassesInconsistentGenericTypes.java @@ -4,6 +4,7 @@ import org.jetbrains.annotations.NotNull; import java.util.List; import jet.runtime.typeinfo.KotlinSignature; +import org.jetbrains.jet.jvm.compiler.annotation.ExpectLoadError; public interface TwoSuperclassesInconsistentGenericTypes { @KotlinSignature("fun foo(): MutableList") @@ -15,6 +16,7 @@ public interface TwoSuperclassesInconsistentGenericTypes { } public class Sub implements TwoSuperclassesInconsistentGenericTypes, Other { + @ExpectLoadError("Incompatible return types in super types: [String?, String]") public List foo() { throw new UnsupportedOperationException(); }