[TEST] Migrate AbstractDiagnosticsWithUnsignedTypes to new test runners

compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.fir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun ubyte(vararg a: UByte) {}
+fun ushort(vararg a: UShort) {}
+fun uint(vararg a: UInt) {}
+fun ulong(vararg a: ULong) {}
+
+class ValueParam(vararg val a: ULong)
+
+annotation class Ann(vararg val a: <!INVALID_TYPE_OF_ANNOTATION_MEMBER!>UInt<!>)
+
+fun array(vararg a: UIntArray) {}

compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.fir.kt

@@ -0,0 +1 @@
+val foo = <!INAPPLICABLE_CANDIDATE!>UInt<!>()

compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.kt

@@ -1 +1 @@
-val foo = <!INVISIBLE_MEMBER!>UInt<!>(<!NO_VALUE_FOR_PARAMETER!>)<!>
+val foo = <!INVISIBLE_MEMBER!>UInt<!>(<!NO_VALUE_FOR_PARAMETER!>)<!>

compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt

@@ -0,0 +1,69 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+// FILE: annotation.kt
+
+package kotlin.internal
+
+annotation class ImplicitIntegerCoercion
+
+// FILE: test.kt
+
+import kotlin.internal.ImplicitIntegerCoercion
+
+@ImplicitIntegerCoercion
+const val IMPLICIT_INT = 255
+
+@ImplicitIntegerCoercion
+const val EXPLICIT_INT: Int = 255
+
+@ImplicitIntegerCoercion
+const val LONG_CONST = 255L
+
+@ImplicitIntegerCoercion
+val NON_CONST = 255
+
+@ImplicitIntegerCoercion
+const val BIGGER_THAN_UBYTE = 256
+
+@ImplicitIntegerCoercion
+const val UINT_CONST = 42u
+
+fun takeUByte(@ImplicitIntegerCoercion u: UByte) {}
+fun takeUShort(@ImplicitIntegerCoercion u: UShort) {}
+fun takeUInt(@ImplicitIntegerCoercion u: UInt) {}
+fun takeULong(@ImplicitIntegerCoercion u: ULong) {}
+
+fun takeUBytes(@ImplicitIntegerCoercion vararg u: UByte) {}
+
+fun takeLong(@ImplicitIntegerCoercion l: Long) {}
+
+fun takeUIntWithoutAnnotaion(u: UInt) {}
+
+fun takeIntWithoutAnnotation(i: Int) {}
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(IMPLICIT_INT)
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(EXPLICIT_INT)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUShort<!>(IMPLICIT_INT)
+    <!INAPPLICABLE_CANDIDATE!>takeUShort<!>(BIGGER_THAN_UBYTE)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(IMPLICIT_INT)
+
+    <!INAPPLICABLE_CANDIDATE!>takeULong<!>(IMPLICIT_INT)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUBytes<!>(IMPLICIT_INT, EXPLICIT_INT, 42u)
+
+    <!INAPPLICABLE_CANDIDATE!>takeLong<!>(IMPLICIT_INT)
+
+    takeIntWithoutAnnotation(IMPLICIT_INT)
+
+    takeUIntWithoutAnnotaion(UINT_CONST)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(LONG_CONST)
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(NON_CONST)
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(BIGGER_THAN_UBYTE)
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(UINT_CONST)
+    <!INAPPLICABLE_CANDIDATE!>takeUIntWithoutAnnotaion<!>(IMPLICIT_INT)
+}

compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt

@@ -55,7 +55,7 @@ fun test() {
 
     takeUBytes(IMPLICIT_INT, EXPLICIT_INT, 42u)
 
-    takeLong(<!NI;TYPE_MISMATCH!>IMPLICIT_INT<!>)
+    takeLong(<!TYPE_MISMATCH{NI}!>IMPLICIT_INT<!>)
 
     takeIntWithoutAnnotation(IMPLICIT_INT)
 
@@ -63,7 +63,7 @@ fun test() {
 
     takeUByte(<!TYPE_MISMATCH!>LONG_CONST<!>)
     takeUByte(<!TYPE_MISMATCH!>NON_CONST<!>)
-    takeUByte(<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
+    takeUByte(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
     takeUByte(<!TYPE_MISMATCH!>UINT_CONST<!>)
     takeUIntWithoutAnnotaion(<!TYPE_MISMATCH!>IMPLICIT_INT<!>)
-}
+}

compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt

@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+// !CHECK_TYPE
+// !WITH_NEW_INFERENCE
+
+// Here we mostly trying to fix behaviour in order to track changes in inference rules for unsigned types later
+
+fun <T> id(x: T): T = x
+fun <K> select(x: K, y: K): K = TODO()
+
+fun takeUByte(u: UByte) {}
+
+fun foo() {
+    select(1, 1u) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Comparable<*>>() }
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(id(1))
+
+    1 <!NONE_APPLICABLE!>+<!> 1u
+    (1u <!NONE_APPLICABLE!>+<!> 1) <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><UInt>() }
+
+    <!INAPPLICABLE_CANDIDATE!>id<!><UInt>(1)
+}

compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt

@@ -10,11 +10,11 @@ fun <K> select(x: K, y: K): K = TODO()
 fun takeUByte(u: UByte) {}
 
 fun foo() {
-    <!NI;TYPE_MISMATCH!>select<!>(1, 1u) checkType { <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Comparable<*>>() }
-    takeUByte(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>id(1)<!>)
+    <!TYPE_MISMATCH{NI}!>select<!>(1, 1u) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Comparable<*>>() }
+    takeUByte(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>id(1)<!>)
 
     1 <!NONE_APPLICABLE!>+<!> 1u
     (1u + <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>) checkType { _<UInt>() }
 
     id<UInt>(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>)
-}
+}

compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.fir.kt

@@ -0,0 +1,14 @@
+fun UInt.fUInt() {}
+fun UByte.fUByte() {}
+fun UShort.fUShort() {}
+fun ULong.fULong() {}
+
+fun test() {
+    1.<!INAPPLICABLE_CANDIDATE!>fUInt<!>()
+    1.<!INAPPLICABLE_CANDIDATE!>fUByte<!>()
+    1.<!INAPPLICABLE_CANDIDATE!>fUShort<!>()
+    1.<!INAPPLICABLE_CANDIDATE!>fULong<!>()
+
+    3000000000 <!NONE_APPLICABLE!>until<!> 3000000004UL
+    0 <!NONE_APPLICABLE!>until<!> 10u
+}

compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.fir.kt

@@ -0,0 +1,35 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !CHECK_TYPE
+
+fun foo(x: Int): Int = 0
+
+fun foo(x: UInt): String = ""
+fun foo(x: UByte): String = ""
+fun foo(x: UShort): String = ""
+fun foo(x: ULong): String = ""
+
+fun fooByte(x: Byte): Int = 0
+fun fooByte(x: UByte): String = ""
+
+fun fooShort(x: Short): Int = 0
+fun fooShort(x: UShort): String = ""
+
+fun fooLong(x: Long): Int = 0
+fun fooLong(x: ULong): String = ""
+
+fun test() {
+    foo(1) checkType { _<Int>() }
+    foo(1u) checkType { _<String>() }
+
+    <!NONE_APPLICABLE!>foo<!>(2147483648) <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    foo(2147483647 + 1) checkType { _<Int>() }
+
+    fooByte(1) checkType { _<Int>() }
+    fooByte(1u) checkType { _<String>() }
+
+    fooShort(1) checkType { _<Int>() }
+    fooShort(1u) checkType { _<String>() }
+
+    fooLong(1) checkType { _<Int>() }
+    fooLong(1u) checkType { _<String>() }
+}

compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt

@@ -32,4 +32,4 @@ fun test() {
 
     fooLong(1) checkType { _<Int>() }
     fooLong(1u) checkType { _<String>() }
-}
+}

compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt

@@ -0,0 +1,65 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+fun takeUByte(u: UByte) {}
+fun takeUShort(u: UShort) {}
+fun takeUInt(u: UInt) {}
+fun takeULong(u: ULong) {}
+
+fun takeUBytes(vararg u: UByte) {}
+
+fun takeNullableUInt(u: UInt?) {}
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(1 + 2)
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(1.plus(2))
+    <!INAPPLICABLE_CANDIDATE!>takeNullableUInt<!>(4)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(Int.MAX_VALUE * 2L)
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(-1)
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(Int.MAX_VALUE * 2L + 2)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(1)
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(255)
+    <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(1.toByte())
+
+    <!INAPPLICABLE_CANDIDATE!>takeUShort<!>(1)
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(1)
+    <!INAPPLICABLE_CANDIDATE!>takeULong<!>(1)
+
+    takeULong(<!ILLEGAL_CONST_EXPRESSION!>18446744073709551615<!>)
+    <!INAPPLICABLE_CANDIDATE!>takeULong<!>(1844674407370955161)
+    takeULong(18446744073709551615u)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(Int.MAX_VALUE * 2)
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(4294967294)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUBytes<!>(1, 2, 255, 256, 0, -1, 40 + 2)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(1.myPlus(2))
+
+    val localVariable = 42
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(localVariable)
+
+    var localMutableVariable = 42
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(localMutableVariable)
+
+    val localNegativeVariable = -1
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(localNegativeVariable)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(globalVariable)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(constVal)
+
+    <!INAPPLICABLE_CANDIDATE!>takeUInt<!>(globalVariableWithGetter)
+}
+
+val globalVariable = 10
+
+const val constVal = 10
+
+val globalVariableWithGetter: Int get() = 0
+
+val prop: UByte = 255
+
+fun Int.myPlus(other: Int): Int = this + other

compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt

@@ -27,7 +27,7 @@ fun test() {
     takeUInt(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>)
     takeULong(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>)
 
-    takeULong(<!INT_LITERAL_OUT_OF_RANGE, NI;TYPE_MISMATCH!>18446744073709551615<!>)
+    takeULong(<!INT_LITERAL_OUT_OF_RANGE, TYPE_MISMATCH{NI}!>18446744073709551615<!>)
     takeULong(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1844674407370955161<!>)
     takeULong(18446744073709551615u)
 

compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.fir.kt

@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+val a0: Int = 1uL
+val a1: UInt = 1uL
+val a3: ULong = 1uL
+val a4 = 1UL + 2UL
+val a5 = <!UNRESOLVED_REFERENCE!>-<!>1UL
+
+fun takeULong(u: ULong) {}
+
+fun test() {
+    takeULong(3UL)
+    takeULong(1UL + 3uL)
+    takeULong(1u + 0uL)
+    takeULong(1uL + 4u)
+}

compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.kt

@@ -13,4 +13,4 @@ fun test() {
     takeULong(1UL + 3uL)
     takeULong(1u + 0uL)
     takeULong(1uL + 4u)
-}
+}

compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.fir.kt

@@ -0,0 +1,23 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun test(
+    ub1: UByte, ub2: UByte,
+    us1: UShort, us2: UShort,
+    ui1: UInt, ui2: UInt,
+    ul1: ULong, ul2: ULong
+) {
+    val ub = ub1 === ub2 || ub1 !== ub2
+    val us = us1 === us2 || us1 !== us2
+    val ui = ui1 === ui2 || ui1 !== ui2
+    val ul = ul1 === ul2 || ul1 !== ul2
+
+    val u = ub1 === ul1
+
+    val a1 = 1u === 2u || 1u !== 2u
+    val a2 = 0xFFFF_FFFF_FFFF_FFFFu === 0xFFFF_FFFF_FFFF_FFFFu
+
+    val bu1 = 1u
+    val bu2 = 1u
+
+    val c1 = bu1 === bu2 || bu1 !== bu2
+}

compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.fir.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+lateinit var a: UInt
+
+fun foo() {
+    lateinit var b: UByte
+    lateinit var c: UShort
+    lateinit var d: ULong
+}

compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 
 fun test() {

compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 
 const val u0 = 1u
 const val u1: UByte = 2u

compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.fir.kt

@@ -0,0 +1,6 @@
+// !API_VERSION: 1.2
+
+val a = 0u
+val b = 1uL
+
+fun foo(u: UInt) {}

compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.fir.kt

@@ -0,0 +1,25 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+const val u1: UByte = 0xFFu
+const val u2: UShort = 0xFFFFu
+const val u3: UInt = 0xFFFF_FFFFu
+const val u4: ULong = 0xFFFF_FFFF_FFFF_FFFFu
+const val u5: ULong = 18446744073709551615u
+
+const val u6 = 0xFFFF_FFFF_FFFF_FFFFu
+const val u7 = 18446744073709551615u
+
+val u8: Comparable<*> = 0xFFFF_FFFF_FFFF_FFFFu
+
+const val u9 = 0xFFFF_FFFF_FFFF_FFFFUL
+
+fun takeUByte(ubyte: UByte) {}
+
+fun test() {
+    takeUByte(200u)
+    takeUByte(255u)
+    takeUByte(0xFFu)
+}
+
+val s1: UByte = 256u
+val s2 = <!ILLEGAL_CONST_EXPRESSION!>18446744073709551616u<!>

compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.kt

@@ -22,4 +22,4 @@ fun test() {
 }
 
 val s1: UByte = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>256u<!>
-val s2 = <!INT_LITERAL_OUT_OF_RANGE!>18446744073709551616u<!>
+val s2 = <!INT_LITERAL_OUT_OF_RANGE!>18446744073709551616u<!>

compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.fir.kt

@@ -0,0 +1,23 @@
+
+val a0: Any = 1u
+
+val n0: Number = 1u
+
+val c0: Comparable<*> = 1u
+val c1: Comparable<UInt> = 1u
+
+val u0: UInt = 1u
+val u1: UInt? = 1u
+val u2: UInt? = u0
+val u3: UInt? = u1
+
+val i0: Int = 1u
+
+val m0 = <!UNRESOLVED_REFERENCE!>-<!>1u
+val m1: UInt = <!UNRESOLVED_REFERENCE!>-<!>1u
+
+val h1 = 0xFFu
+val h2: UShort = 0xFFu
+
+val b1 = 0b11u
+val b2: UByte = 0b11u

compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.kt

@@ -20,4 +20,4 @@ val h1 = 0xFFu
 val h2: UShort = 0xFFu
 
 val b1 = 0b11u
-val b2: UByte = 0b11u
+val b2: UByte = 0b11u

compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt

@@ -0,0 +1,7 @@
+
+fun ubyte(vararg a: UByte): UByteArray = a
+fun ushort(vararg a: UShort): UShortArray = a
+fun uint(vararg a: UInt): UIntArray = a
+fun ulong(vararg a: ULong): ULongArray = a
+
+fun rawUInt(vararg a: UInt): IntArray = a

compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.fir.kt

@@ -0,0 +1,4 @@
+val a1 = 1ul
+val a2 = 0x1ul
+val a3 = 0B1ul
+val a4 = 1Ul