azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FE 1.0] Migrate most of warning/error pairs to DiagnosticFactoryForDeprecation

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2021-07-30 13:26:35 +03:00
parent 7c73840e4a
commit d17f984edf
74 changed files with 285 additions and 411 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/codegen/box/intrinsics/javaPrimitiveType_UnitAndNothing.kt
Vendored
+2 -2
View File
@@ -10,8 +10,8 @@ fun box(): String {
assertEquals(null, pNUnit!!::class.javaPrimitiveType)
assertEquals(null, Unit::class.javaPrimitiveType)
@Suppress("TYPE_INFERENCE_ONLY_INPUT_TYPES")
@Suppress("TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR")
assertEquals(java.lang.Void.TYPE, Nothing::class.javaPrimitiveType)
return "OK"
}
}
compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.kt
Vendored
+4 -4
View File
@@ -84,9 +84,9 @@ fun main(a: test.A, l: L<Map<String, Int>, Int?>, l1: L<Map<String, Int>, Int>)
a.bar(<!TYPE_MISMATCH!>l1 <!UNCHECKED_CAST!>as L<Map<String, Int>, Int?><!><!>)
a.baz1().t().containsKey("")
a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(null)
a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsKey<!>(null)
a.baz1().t().containsValue(1)
a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsValue<!>(null)
a.baz1().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsValue<!>(null)
a.baz1().s().hashCode()
a.baz1().setT(l.t())
@@ -100,8 +100,8 @@ fun main(a: test.A, l: L<Map<String, Int>, Int?>, l1: L<Map<String, Int>, Int>)
a.baz2().s().hashCode()
a.baz3().t().containsKey("")
a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(null)
a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsKey<!>(null)
a.baz3().t().containsValue(1)
a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsValue<!>(null)
a.baz3().t().<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsValue<!>(null)
a.baz3().s().hashCode()
}
compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_after.kt
Vendored
+3 -3
View File
@@ -6,9 +6,9 @@
annotation class TestRetentionSource
@Target(AnnotationTarget.EXPRESSION)
<!RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION!>@Retention(AnnotationRetention.BINARY)<!>
<!RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_ERROR!>@Retention(AnnotationRetention.BINARY)<!>
annotation class TestRetentionBinary
@Target(AnnotationTarget.EXPRESSION)
<!RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION!>@Retention(AnnotationRetention.RUNTIME)<!>
annotation class TestRetentionRuntime
<!RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_ERROR!>@Retention(AnnotationRetention.RUNTIME)<!>
annotation class TestRetentionRuntime
compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992_after.kt
Vendored
+2 -2
View File
@@ -6,6 +6,6 @@ interface Foo
@Target(AnnotationTarget.TYPE)
annotation class Ann
class E : <!ANNOTATION_ON_SUPERCLASS!>@field:Ann<!> <!ANNOTATION_ON_SUPERCLASS!>@get:Ann<!> <!ANNOTATION_ON_SUPERCLASS!>@set:Ann<!> <!ANNOTATION_ON_SUPERCLASS!>@setparam:Ann<!> Foo
class E : <!ANNOTATION_ON_SUPERCLASS_ERROR!>@field:Ann<!> <!ANNOTATION_ON_SUPERCLASS_ERROR!>@get:Ann<!> <!ANNOTATION_ON_SUPERCLASS_ERROR!>@set:Ann<!> <!ANNOTATION_ON_SUPERCLASS_ERROR!>@setparam:Ann<!> Foo
interface G : @Ann Foo
interface G : @Ann Foo
compiler/testData/diagnostics/tests/backingField/FieldReassignment_before.kt
Vendored
+2 -2
View File
@@ -3,6 +3,6 @@
val my: Int = 1
get() {
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD!>field<!>++
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD_WARNING!>field<!>++
return field
}
}
compiler/testData/diagnostics/tests/classObjects/selfCallsInCompanionSuperConstructor_error.kt
Vendored
+5 -5
View File
@@ -4,19 +4,19 @@
abstract class Base(val baseProp: String)
open class Foo1(val prop: Int, baseProp: String) : Base(baseProp) {
companion object : Foo1(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>baseProp<!>)
companion object : Foo1(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>baseProp<!>)
}
open class Foo2(val prop: Int, baseProp: String) : Base(baseProp) {
companion object : Foo2(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>baseProp<!><!>)
companion object : Foo2(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>this.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>baseProp<!><!>)
}
open class Foo3(val prop: Int, baseProp: String) : Base(baseProp) {
companion object : Foo3(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>baseProp<!><!>)
companion object : Foo3(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>Companion.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>baseProp<!><!>)
}
open class Foo4(val prop: Int, baseProp: String) : Base(baseProp) {
object MyObject : Foo4(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>baseProp<!><!>)
object MyObject : Foo4(<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!><!>, <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>MyObject.<!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>baseProp<!><!>)
}
open class CheckNested(a: Any) {
@@ -26,5 +26,5 @@ open class CheckNested(a: Any) {
}
open class Foo5(val prop: Int) {
object MyObject : Foo5(with(MyObject) { <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR!>prop<!> })
object MyObject : Foo5(with(MyObject) { <!SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_ERROR!>prop<!> })
}
compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_before.kt
Vendored
+2 -2
View File
@@ -8,7 +8,7 @@ import java.util.HashSet
val a: MutableSet<String>? = null
get() {
if (a == null) {
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD!>field<!> = HashSet()
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD_WARNING!>field<!> = HashSet()
}
return a
}
@@ -17,7 +17,7 @@ class R {
val b: String? = null
get() {
if (b == null) {
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD!>field<!> = "b"
<!VAL_REASSIGNMENT_VIA_BACKING_FIELD_WARNING!>field<!> = "b"
}
return b
}
compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgument.kt
Vendored
+2 -2
View File
@@ -6,8 +6,8 @@ inline fun <reified T> foo() {}
fun <T> bar() {
foo<<!TYPE_PARAMETER_AS_REIFIED!>T<!>>()
foo<<!TYPE_PARAMETER_AS_REIFIED_ARRAY!>Array<T><!>>()
foo<<!TYPE_PARAMETER_AS_REIFIED_ARRAY!>Array<Array<T>><!>>()
foo<<!TYPE_PARAMETER_AS_REIFIED_ARRAY_ERROR!>Array<T><!>>()
foo<<!TYPE_PARAMETER_AS_REIFIED_ARRAY_ERROR!>Array<Array<T>><!>>()
foo<Array<Int>>()
foo<Array<Array<Int>>>()
foo<IntArray>()
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt
Vendored
+4 -4
View File
@@ -444,7 +444,7 @@ fun poll8(): Flow<String> {
fun poll81(): Flow<String> {
return flow {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
@@ -458,7 +458,7 @@ fun poll82(): Flow<String> {
fun poll83(): Flow<String> {
return flow {
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo4)
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo4)
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
}
@@ -486,8 +486,8 @@ fun poll86(): Flow<String> {
fun poll87(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo7<!>())
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>inv<!>
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>foo7<!>())
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>inv<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt
Vendored
+2 -2
View File
@@ -57,14 +57,14 @@ fun poll75(): Flow<String> {
fun poll81(): Flow<String> {
return flow {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
fun poll83(): Flow<String> {
return flow {
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo4)
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo4)
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt
Vendored
+2 -2
View File
@@ -22,14 +22,14 @@ class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
fun poll81(): Flow<String> {
return flow {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
fun poll83(): Flow<String> {
return flow {
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo4)
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo4)
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt
Vendored
+4 -4
View File
@@ -445,7 +445,7 @@ fun poll8(): Flow<String> {
fun poll81(): Flow<String> {
return flow {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
}
}
@@ -459,7 +459,7 @@ fun poll82(): Flow<String> {
fun poll83(): Flow<String> {
return flow {
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo4)
val inv = ::bar4 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo4)
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
}
@@ -487,8 +487,8 @@ fun poll86(): Flow<String> {
fun poll87(): Flow<String> {
return flow {
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo7<!>())
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>inv<!>
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>foo7<!>())
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>inv<!>
}
}
compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.kt
Vendored
+2 -2
View File
@@ -274,7 +274,7 @@ fun poll8() {
}
fun poll81() {
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(::foo2)
val inv = ::bar2 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(::foo2)
<!DEBUG_INFO_MISSING_UNRESOLVED!>inv<!>()
}
@@ -304,7 +304,7 @@ fun poll86() {
}
fun poll87() {
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(foo7())
val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> setOf(foo7())
<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
}
compiler/testData/diagnostics/tests/inline/protectedCallDepecation.kt
Vendored
+9 -9
View File
@@ -18,10 +18,10 @@ open class A {
protected set(value) {}
inline fun call() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>z<!>
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>z<!>
zVar
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>zVar<!> = "123"
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>zVar<!> = "123"
}
internal inline fun callFromInternal() {
@@ -32,10 +32,10 @@ open class A {
@PublishedApi
internal inline fun callFromPublished() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>z<!>
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>z<!>
zVar
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>zVar<!> = "123"
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>zVar<!> = "123"
}
protected inline fun callFromProtected() {
@@ -48,13 +48,13 @@ open class A {
class B : A() {
inline fun testB() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>test<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>test<!>()
}
}
class C : JavaClass() {
inline fun call() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>bind<!>()
}
internal inline fun callFromInternal() {
@@ -67,7 +67,7 @@ class C : JavaClass() {
@PublishedApi
internal inline fun callFromPublished() {
<!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>()
<!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>bind<!>()
}
}
compiler/testData/diagnostics/tests/j+k/defaultMethods_warning.kt
Vendored
+16 -16
View File
@@ -22,7 +22,7 @@ import JavaInterface.testStatic
interface KotlinInterface : JavaInterface {
fun fooo() {
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.<!INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER!>test<!>()
object {
@@ -51,7 +51,7 @@ interface KotlinInterface : JavaInterface {
interface KotlinInterfaceIndirectInheritance : KotlinInterface {
fun foooo() {
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.<!INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER!>test<!>()
object {
@@ -76,25 +76,25 @@ interface KotlinInterfaceIndirectInheritance : KotlinInterface {
open class KotlinClass : JavaInterface {
fun foo(){
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>testOverride<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testOverride<!>()
object {
fun run () {
super@KotlinClass.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super@KotlinClass.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
}
}
}
val property: String
get() {
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>testOverride<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testOverride<!>()
object {
fun run () {
super@KotlinClass.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super@KotlinClass.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
}
}
return ""
@@ -103,7 +103,7 @@ open class KotlinClass : JavaInterface {
class KotlinClassIndirectInheritance : KotlinClass() {
fun foo2(){
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.test()
super.testOverride()
@@ -130,25 +130,25 @@ class KotlinClassIndirectInheritance : KotlinClass() {
class KotlinClassIndirectInheritance2 : KotlinInterfaceIndirectInheritance {
fun foo(){
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
super.testOverride()
object {
fun run () {
super@KotlinClassIndirectInheritance2.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super@KotlinClassIndirectInheritance2.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
}
}
}
val property: String
get() {
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
super.testOverride()
object {
fun run () {
super@KotlinClassIndirectInheritance2.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET!>test<!>()
super@KotlinClassIndirectInheritance2.<!DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>test<!>()
}
}
return ""
@@ -156,7 +156,7 @@ class KotlinClassIndirectInheritance2 : KotlinInterfaceIndirectInheritance {
}
fun test() {
JavaInterface.<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET!>testStatic<!>()
JavaInterface.<!INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_WARNING!>testStatic<!>()
KotlinClass().foo()
KotlinClass().property
KotlinClassIndirectInheritance2().foo()
compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt
Vendored
+3 -3
View File
@@ -5,7 +5,7 @@ import java.lang.invoke.MethodHandle
fun test(mh: MethodHandle) {
mh.invokeExact("1", "2")
mh.invokeExact(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL!>*<!>emptyArray(), "X")
mh.invokeExact(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL!>*<!>arrayOf("A", "B"), "C", <!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL!>*<!>arrayOf("D", "E"))
mh.invoke(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL!>*<!>arrayOf("A"))
mh.invokeExact(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_WARNING!>*<!>emptyArray(), "X")
mh.invokeExact(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_WARNING!>*<!>arrayOf("A", "B"), "C", <!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_WARNING!>*<!>arrayOf("D", "E"))
mh.invoke(<!SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_WARNING!>*<!>arrayOf("A"))
}
compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.kt
Vendored
+2 -2
View File
@@ -1,9 +1,9 @@
// !LANGUAGE: -ProhibitLocalAnnotations
fun f() {
<!LOCAL_ANNOTATION_CLASS!>annotation class Anno<!>
<!LOCAL_ANNOTATION_CLASS_WARNING!>annotation class Anno<!>
@Anno class Local {
<!LOCAL_ANNOTATION_CLASS!>annotation <!NESTED_CLASS_NOT_ALLOWED!>class Nested<!><!>
<!LOCAL_ANNOTATION_CLASS_WARNING!>annotation <!NESTED_CLASS_NOT_ALLOWED!>class Nested<!><!>
}
}
compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt
Vendored
+1 -1
View File
@@ -18,7 +18,7 @@ fun <T> javaClass(): Class<T> = null!!
public class AppServiceModule : AbstractModule<String>() {
inline fun <reified T> AbstractModule<Int>.bind() {
val x = <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>(javaClass<T>())
val x = <!PROTECTED_CALL_FROM_PUBLIC_INLINE_WARNING!>bind<!>(javaClass<T>())
x checkType { _<String>() } // check that Class receiver is used instead of extension one
}
compiler/testData/diagnostics/tests/tailRecOnVirtualMember.kt
Vendored
+16 -16
View File
@@ -1,15 +1,15 @@
//!LANGUAGE: -ProhibitTailrecOnVirtualMember
open class A {
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec open fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec open fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>internal tailrec open fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>internal tailrec open fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>protected tailrec open fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>protected tailrec open fun baz(y: Int)<!> {
baz(y)
}
@@ -38,15 +38,15 @@ open class B : A() {
open class C : A() {
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun baz(y: Int)<!> {
baz(y)
}
}
@@ -66,15 +66,15 @@ object D : A() {
}
sealed class E : A() {
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec override fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec override fun baz(y: Int)<!> {
baz(y)
}
@@ -109,15 +109,15 @@ enum class F {
}
};
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec open fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec open fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>internal tailrec open fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>internal tailrec open fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>protected tailrec open fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>protected tailrec open fun baz(y: Int)<!> {
baz(y)
}
@@ -134,15 +134,15 @@ enum class G {
G1;
<!TAILREC_ON_VIRTUAL_MEMBER!>tailrec open fun foo(x: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>tailrec open fun foo(x: Int)<!> {
foo(x)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>internal tailrec open fun bar(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>internal tailrec open fun bar(y: Int)<!> {
bar(y)
}
<!TAILREC_ON_VIRTUAL_MEMBER!>protected tailrec open fun baz(y: Int)<!> {
<!TAILREC_ON_VIRTUAL_MEMBER_WARNING!>protected tailrec open fun baz(y: Int)<!> {
baz(y)
}
@@ -168,4 +168,4 @@ val z = object : A() {
tailrec override fun baz(y: Int) {
baz(y)
}
}
}
compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt
Vendored
+2 -2
View File
@@ -11,7 +11,7 @@
annotation class Ann(vararg val s: String)
@Ann(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION!>"value"<!>)
@Ann(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_WARNING!>"value"<!>)
fun test1() {}
@Ann(s = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION!>arrayOf("value")<!>)
@@ -20,7 +20,7 @@ fun test2() {}
@Ann(s = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION!>["value"]<!>)
fun test3() {}
@JavaAnn(value = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION!>"value"<!>)
@JavaAnn(value = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_WARNING!>"value"<!>)
fun test4() {}
@JavaAnn("value", path = arrayOf("path"))
compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt
Vendored
+18 -18
View File
@@ -6,41 +6,41 @@ fun foo(vararg s: Int) {}
open class Cls(vararg p: Long)
fun test(i: IntArray) {
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, TYPE_MISMATCH!>i<!>)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING, TYPE_MISMATCH!>i<!>)
foo(s = *i)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, TYPE_MISMATCH!>intArrayOf(1)<!>)
foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING, TYPE_MISMATCH!>intArrayOf(1)<!>)
foo(s = *intArrayOf(1))
foo(1)
Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
class Sub : Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
class Sub : Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
val c = object : Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>) {}
val c = object : Cls(p = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>) {}
foo(s = *intArrayOf(elements = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>))
foo(s = *intArrayOf(elements = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>))
}
fun anyFoo(vararg a: Any) {}
fun testAny() {
anyFoo(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>""<!>)
anyFoo(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>arrayOf("")<!>)
anyFoo(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>""<!>)
anyFoo(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>arrayOf("")<!>)
anyFoo(a = *arrayOf(""))
}
fun <T> genFoo(vararg t: T) {}
fun testGen() {
genFoo<Int>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
genFoo<Int?>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>null<!>)
genFoo<Array<Int>>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>arrayOf()<!>)
genFoo<Int>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
genFoo<Int?>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>null<!>)
genFoo<Array<Int>>(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>arrayOf()<!>)
genFoo<Array<Int>>(t = *arrayOf(arrayOf()))
genFoo(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>""<!>)
genFoo(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>arrayOf("")<!>)
genFoo(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>""<!>)
genFoo(t = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>arrayOf("")<!>)
genFoo(t = *arrayOf(""))
}
@@ -48,12 +48,12 @@ fun manyFoo(vararg v: Int) {}
fun manyFoo(vararg s: String) {}
fun testMany(a: Any) {
manyFoo(v = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
manyFoo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>""<!>)
manyFoo(v = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>1<!>)
manyFoo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>""<!>)
<!NONE_APPLICABLE!>manyFoo<!>(a)
<!NONE_APPLICABLE!>manyFoo<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>v<!> = a)
<!NONE_APPLICABLE!>manyFoo<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>s<!> = a)
manyFoo(v = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>a as Int<!>)
manyFoo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>a as String<!>)
manyFoo(v = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>a as Int<!>)
manyFoo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_WARNING!>a as String<!>)
}
compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromJava.kt
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ public abstract class Base {
package impl
import base.*
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class Impl<!> : Base()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class Impl<!> : Base()
fun foo() {
Impl().foo()
compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.kt
Vendored
+3 -3
View File
@@ -28,9 +28,9 @@ package impl
import base.*
import intermediate.*
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class ImplDirectFromBase<!> : Base()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class ImplDirectFromBase<!> : Base()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>object ImplObjDirectFromBase<!> : Base()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>object ImplObjDirectFromBase<!> : Base()
class ImplDirectFromBaseWithOverride : BaseWithOverride()
@@ -38,7 +38,7 @@ class ImplDirectFromBaseWithOverrid : Base() {
<!CANNOT_OVERRIDE_INVISIBLE_MEMBER!>override<!> fun internalFoo(): String = ""
}
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER!>class ImplViaIntermediate<!> : Intermediate()
<!INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_ERROR!>class ImplViaIntermediate<!> : Intermediate()
fun foo() {
ImplDirectFromBase().foo()
compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt
Vendored
+1 -1
View File
@@ -50,6 +50,6 @@ fun test6() = <!UNSUPPORTED!>foo<!><Nothing>()
class B<T>(val array: Array<T>)
fun <T> bar() = B<Array<T>>(<!TYPE_PARAMETER_AS_REIFIED_ARRAY!>arrayOf<!>())
fun <T> bar() = B<Array<T>>(<!TYPE_PARAMETER_AS_REIFIED_ARRAY_ERROR!>arrayOf<!>())
fun test7() = <!UNSUPPORTED!>bar<!><Nothing>()
compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
// !LANGUAGE: +ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses
annotation class A1 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor(val x: Int = 1)
annotation class A2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR!>@JvmOverloads<!> constructor()
annotation class A1 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor(val x: Int = 1)
annotation class A2 <!OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_ERROR!>@JvmOverloads<!> constructor()
compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt
Vendored
+2 -2
View File
@@ -3,7 +3,7 @@ interface A
class B : A
fun foo1(list: List<A>, arg: B?): Boolean {
// Type mismatch
return arg <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> list // resolved to extension
return arg <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> list // resolved to extension
}
fun foo2(list: List<A>, arg: B?): Boolean {
// FAKE: no cast needed
@@ -17,4 +17,4 @@ fun foo3(list: List<A>, arg: B?): Boolean {
fun foo4(list: List<A>, arg: B): Boolean {
// Ok
return arg in list
}
}
compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt
Vendored
+4 -4
View File
@@ -2,7 +2,7 @@ import java.util.*
fun foo() {
val al = ArrayList<String>()
al.size
al.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains<!>(1)
al.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains<!>(1)
al.contains("")
al.remove("")
@@ -10,7 +10,7 @@ fun foo() {
val hs = HashSet<String>()
hs.size
hs.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains<!>(1)
hs.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains<!>(1)
hs.contains("")
hs.remove("")
@@ -18,10 +18,10 @@ fun foo() {
val hm = HashMap<String, Int>()
hm.size
hm.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>containsKey<!>(1)
hm.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>containsKey<!>(1)
hm.containsKey("")
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>hm[1]<!>
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>hm[1]<!>
hm[""]
hm.remove("")
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.kt
Vendored
+1 -1
View File
@@ -7,6 +7,6 @@ object ChildB : Parent
fun <@kotlin.internal.OnlyInputTypes T> select(a: T, b: T) {}
fun test() {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>select<!>(ChildA, ChildB) // should be error
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>select<!>(ChildA, ChildB) // should be error
select<Any>(ChildA, ChildB) // should be ok
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt
Vendored
+3 -3
View File
@@ -15,7 +15,7 @@ fun <@kotlin.internal.OnlyInputTypes T : Base> fooB(a: T, b: T) {}
fun usage(x: CX, y: CY) {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo<!>(x, y) // expected err, got err
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>fooA<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>fooB<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>foo<!>(x, y) // expected err, got err
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>fooA<!>(x, y) // expected err, got ok
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>fooB<!>(x, y) // expected err, got ok
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt
Vendored
+2 -2
View File
@@ -2,7 +2,7 @@
// ISSUE: KT-29307
fun test_1(map: Map<String, String>) {
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>map[42]<!> // OK
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>map[42]<!> // OK
}
open class A
@@ -10,7 +10,7 @@ open class A
class B : A()
fun test_2(map: Map<A, String>) {
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>map[42]<!>
val x = <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>map[42]<!>
}
fun test_3(m: Map<*, String>) {
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt
Vendored
+4 -4
View File
@@ -35,12 +35,12 @@ fun test_4(list: List<Out<Int>>, x: Out<Int>, y: Out<Number>, z: Out<Any>) {
fun test_5(list: List<Inv<Number>>, x: Inv<Number>, y: Inv<Int>, z: Inv<Any>) {
list.contains1(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(y)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(z)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(y)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(z)
}
fun test_6(list: List<Inv<Int>>, x: Inv<Int>, y: Inv<Number>, z: Inv<Any>) {
list.contains1(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(y)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(z)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(y)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(z)
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt
Vendored
+2 -2
View File
@@ -17,9 +17,9 @@ public fun <K, V> Map<K, V>.get1(key: Any?): Int = null!!
public fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get1(key: K): V? = null!!
fun test(map: Map<Int, String>) {
val a: Int = <!TYPE_MISMATCH!>listOf(1).<!TYPE_MISMATCH!><!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>("")<!><!>
val a: Int = <!TYPE_MISMATCH!>listOf(1).<!TYPE_MISMATCH!><!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>("")<!><!>
val b: Boolean = listOf(1).contains1(1)
val c: String? = map.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>get1<!>("")
val c: String? = map.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>get1<!>("")
val d: String? = map.get1(1)
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ fun test(
invOut.onlyOut(42)
invOut.onlyOut(1L)
invOut.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>onlyOutUB<!>(<!TYPE_MISMATCH!>"str"<!>)
invOut.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>onlyOutUB<!>(<!TYPE_MISMATCH!>"str"<!>)
invStar.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>onlyOutUB<!>(0)
invOut.onlyOutUB(42)
invOut.onlyOutUB(1L)
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt
Vendored
+9 -9
View File
@@ -16,7 +16,7 @@ class Out<out T>
// -------------------------------------------------------
fun test_0(x: Inv2<in Number, out Number>, list: List<Inv2<Any, Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>foo<!>(x)
}
// ------------------------- Inv -------------------------
@@ -26,27 +26,27 @@ fun test_1(x: Inv<Number>, list: List<Inv<Number>>) {
}
fun test_2(x: Inv<Number>, list: List<Inv<Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_3(x: Inv<Number>, list: List<Inv<Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_4(x: Inv<in Number>, list: List<Inv<Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_5(x: Inv<in Number>, list: List<Inv<Number>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_6(x: Inv<in Number>, list: List<Inv<Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_7(x: Inv<out Number>, list: List<Inv<Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_8(x: Inv<out Number>, list: List<Inv<Number>>) {
@@ -96,7 +96,7 @@ fun test_32(x: Inv<Number>, list: List<Inv<in Int>>) {
}
fun test_33(x: Inv<Number>, list: List<Inv<in Any>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_34(x: Inv<Number>, list: List<Inv<out Number>>) {
@@ -104,7 +104,7 @@ fun test_34(x: Inv<Number>, list: List<Inv<out Number>>) {
}
fun test_35(x: Inv<Number>, list: List<Inv<out Int>>) {
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>contains1<!>(x)
list.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>contains1<!>(x)
}
fun test_36(x: Inv<Number>, list: List<Inv<out Any>>) {
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt
Vendored
+7 -7
View File
@@ -43,11 +43,11 @@ fun testOK(first: First, bound: Bound, second: Second) {
}
fun testFail(first: First, bound: Bound, second: Second) {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(InvB(first), InvB(bound))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(Inv(first), Inv(bound))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(Out(first), Out(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(In(first), In(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(InB(first), InB(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(Out(Inv(first)), Out(Inv(second)))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>strictSelect<!>(In(Inv(first)), In(Inv(second)))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(InvB(first), InvB(bound))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(Inv(first), Inv(bound))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(Out(first), Out(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(In(first), In(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(InB(first), InB(second))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(Out(Inv(first)), Out(Inv(second)))
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>strictSelect<!>(In(Inv(first)), In(Inv(second)))
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
class Inv<T>
class Out<out T>
fun <T> foo(i: Inv<in T>, o: Out<T>) {
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>bar<!>(i, o)
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>bar<!>(i, o)
}
fun <@kotlin.internal.OnlyInputTypes K> bar(r: Inv<out K>, o: Out<K>): K = TODO()
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ class D
fun test1(a: A, b: B, c: C) {
assertEquals1(a, b)
<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>assertEquals1<!>(b, c)
<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>assertEquals1<!>(b, c)
assertEquals1(3, 3)
assertEquals1(1 or 2, 2 or 1)
compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt
Vendored
+1 -1
View File
@@ -4,6 +4,6 @@
class Base<T : <!CYCLIC_GENERIC_UPPER_BOUND!>T<!>> : HashSet<T>() {
fun foo() {
<!SUPER_CANT_BE_EXTENSION_RECEIVER!>super<!>.<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>remove<!>("")
<!SUPER_CANT_BE_EXTENSION_RECEIVER!>super<!>.<!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>remove<!>("")
}
}
compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt
Vendored
+24 -24
View File
@@ -18,24 +18,24 @@ class C : java.util.concurrent.ConcurrentHashMap<String, Int>() {
fun main() {
val hm = java.util.concurrent.ConcurrentHashMap<String, Int>()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> hm
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> hm
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> hm
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> hm
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> hm
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> hm
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> hm
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> hm
hm.contains("")
hm.contains(1)
"" in (hm as Map<String, Int>)
"" !in (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (hm as Map<String, Int>)
val a = A()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> a
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> a
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> a
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> a
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> a
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> a
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> a
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> a
' ' in a
' ' !in a
@@ -44,35 +44,35 @@ fun main() {
"" in (a as Map<String, Int>)
"" !in (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (a as Map<String, Int>)
val b = B()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> b
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> b
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> b
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> b
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> b
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> b
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> b
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> b
b.contains("")
b.contains(1)
"" in (b as Map<String, Int>)
"" !in (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (b as Map<String, Int>)
// Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird
val c = C()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> c
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> c
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>!in<!> c
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR!>in<!> c
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> c
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> c
1 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>!in<!> c
2 <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_WARNING!>in<!> c
c.contains("")
c.contains(1)
"" in (c as Map<String, Int>)
"" !in (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (c as Map<String, Int>)
}
compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt
Vendored
+8 -8
View File
@@ -28,8 +28,8 @@ fun main() {
"" in (hm as Map<String, Int>)
"" !in (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (hm as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (hm as Map<String, Int>)
val a = A()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR!>in<!> a
@@ -44,8 +44,8 @@ fun main() {
"" in (a as Map<String, Int>)
"" !in (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (a as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (a as Map<String, Int>)
val b = B()
"" <!CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR!>in<!> b
@@ -58,8 +58,8 @@ fun main() {
"" in (b as Map<String, Int>)
"" !in (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (b as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (b as Map<String, Int>)
// Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird
val c = C()
@@ -73,6 +73,6 @@ fun main() {
"" in (c as Map<String, Int>)
"" !in (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>!in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>in<!> (c as Map<String, Int>)
1 <!TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR!>!in<!> (c as Map<String, Int>)
}