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/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>)
}