[TEST] Migrate AbstractDiagnosticsWithUnsignedTypes to new test runners

2020-12-09 12:40:17 +03:00
parent 23e704f361
commit b43fa94cb6
56 changed files with 598 additions and 173 deletions
@@ -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) {}
@@ -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: UInt)
+
+fun array(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> a: UIntArray) {}
@@ -0,0 +1,23 @@
+package
+
+public fun array(/*0*/ vararg a: kotlin.UIntArray /*kotlin.Array<out kotlin.UIntArray>*/): kotlin.Unit
+public fun ubyte(/*0*/ vararg a: kotlin.UByte /*kotlin.UByteArray*/): kotlin.Unit
+public fun uint(/*0*/ vararg a: kotlin.UInt /*kotlin.UIntArray*/): kotlin.Unit
+public fun ulong(/*0*/ vararg a: kotlin.ULong /*kotlin.ULongArray*/): kotlin.Unit
+public fun ushort(/*0*/ vararg a: kotlin.UShort /*kotlin.UShortArray*/): kotlin.Unit
+
+public final annotation class Ann : kotlin.Annotation {
+    public constructor Ann(/*0*/ vararg a: kotlin.UInt /*kotlin.UIntArray*/)
+    public final val a: kotlin.UIntArray
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class ValueParam {
+    public constructor ValueParam(/*0*/ vararg a: kotlin.ULong /*kotlin.ULongArray*/)
+    public final val a: kotlin.ULongArray
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
@@ -0,0 +1 @@
+val foo = <!INAPPLICABLE_CANDIDATE!>UInt<!>()
@@ -0,0 +1 @@
+val foo = <!INVISIBLE_MEMBER!>UInt<!>(<!NO_VALUE_FOR_PARAMETER!>)<!>
@@ -0,0 +1,3 @@
+package
+
+public val foo: kotlin.UInt
@@ -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)
+}
@@ -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() {
+    takeUByte(IMPLICIT_INT)
+    takeUByte(EXPLICIT_INT)
+
+    takeUShort(IMPLICIT_INT)
+    takeUShort(BIGGER_THAN_UBYTE)
+
+    takeUInt(IMPLICIT_INT)
+
+    takeULong(IMPLICIT_INT)
+
+    takeUBytes(IMPLICIT_INT, EXPLICIT_INT, 42u)
+
+    takeLong(<!TYPE_MISMATCH{NI}!>IMPLICIT_INT<!>)
+
+    takeIntWithoutAnnotation(IMPLICIT_INT)
+
+    takeUIntWithoutAnnotaion(UINT_CONST)
+
+    takeUByte(<!TYPE_MISMATCH!>LONG_CONST<!>)
+    takeUByte(<!TYPE_MISMATCH!>NON_CONST<!>)
+    takeUByte(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
+    takeUByte(<!TYPE_MISMATCH!>UINT_CONST<!>)
+    takeUIntWithoutAnnotaion(<!TYPE_MISMATCH!>IMPLICIT_INT<!>)
+}
@@ -0,0 +1,30 @@
+package
+
+@kotlin.internal.ImplicitIntegerCoercion public const val BIGGER_THAN_UBYTE: kotlin.Int = 256
+@kotlin.internal.ImplicitIntegerCoercion public const val EXPLICIT_INT: kotlin.Int = 255
+@kotlin.internal.ImplicitIntegerCoercion public const val IMPLICIT_INT: kotlin.Int = 255
+@kotlin.internal.ImplicitIntegerCoercion public const val LONG_CONST: kotlin.Long = 255.toLong()
+@kotlin.internal.ImplicitIntegerCoercion public val NON_CONST: kotlin.Int = 255
+@kotlin.internal.ImplicitIntegerCoercion public const val UINT_CONST: kotlin.UInt = 42.toUInt()
+public fun takeIntWithoutAnnotation(/*0*/ i: kotlin.Int): kotlin.Unit
+public fun takeLong(/*0*/ @kotlin.internal.ImplicitIntegerCoercion l: kotlin.Long): kotlin.Unit
+public fun takeUByte(/*0*/ @kotlin.internal.ImplicitIntegerCoercion u: kotlin.UByte): kotlin.Unit
+public fun takeUBytes(/*0*/ @kotlin.internal.ImplicitIntegerCoercion vararg u: kotlin.UByte /*kotlin.UByteArray*/): kotlin.Unit
+public fun takeUInt(/*0*/ @kotlin.internal.ImplicitIntegerCoercion u: kotlin.UInt): kotlin.Unit
+public fun takeUIntWithoutAnnotaion(/*0*/ u: kotlin.UInt): kotlin.Unit
+public fun takeULong(/*0*/ @kotlin.internal.ImplicitIntegerCoercion u: kotlin.ULong): kotlin.Unit
+public fun takeUShort(/*0*/ @kotlin.internal.ImplicitIntegerCoercion u: kotlin.UShort): kotlin.Unit
+public fun test(): kotlin.Unit
+
+package kotlin {
+
+    package kotlin.internal {
+
+        public final annotation class ImplicitIntegerCoercion : kotlin.Annotation {
+            public constructor ImplicitIntegerCoercion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
@@ -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)
+}
@@ -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() {
+    <!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<!>)
+}
@@ -0,0 +1,6 @@
+package
+
+public fun foo(): kotlin.Unit
+public fun </*0*/ T> id(/*0*/ x: T): T
+public fun </*0*/ K> select(/*0*/ x: K, /*1*/ y: K): K
+public fun takeUByte(/*0*/ u: kotlin.UByte): kotlin.Unit
@@ -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
+}
@@ -0,0 +1,14 @@
+fun UInt.fUInt() {}
+fun UByte.fUByte() {}
+fun UShort.fUShort() {}
+fun ULong.fULong() {}
+
+fun test() {
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fUInt<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fUByte<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fUShort<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fULong<!>()
+
+    3000000000 until <!CONSTANT_EXPECTED_TYPE_MISMATCH!>3000000004UL<!>
+    0 until <!CONSTANT_EXPECTED_TYPE_MISMATCH!>10u<!>
+}
@@ -0,0 +1,7 @@
+package
+
+public fun test(): kotlin.Unit
+public fun kotlin.UByte.fUByte(): kotlin.Unit
+public fun kotlin.UInt.fUInt(): kotlin.Unit
+public fun kotlin.ULong.fULong(): kotlin.Unit
+public fun kotlin.UShort.fUShort(): kotlin.Unit
@@ -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>() }
+}
@@ -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>() }
+
+    foo(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>2147483648<!>) checkType { _<String>() }
+    foo(<!INTEGER_OVERFLOW!>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>() }
+}
@@ -0,0 +1,14 @@
+package
+
+public fun foo(/*0*/ x: kotlin.Int): kotlin.Int
+public fun foo(/*0*/ x: kotlin.UByte): kotlin.String
+public fun foo(/*0*/ x: kotlin.UInt): kotlin.String
+public fun foo(/*0*/ x: kotlin.ULong): kotlin.String
+public fun foo(/*0*/ x: kotlin.UShort): kotlin.String
+public fun fooByte(/*0*/ x: kotlin.Byte): kotlin.Int
+public fun fooByte(/*0*/ x: kotlin.UByte): kotlin.String
+public fun fooLong(/*0*/ x: kotlin.Long): kotlin.Int
+public fun fooLong(/*0*/ x: kotlin.ULong): kotlin.String
+public fun fooShort(/*0*/ x: kotlin.Short): kotlin.Int
+public fun fooShort(/*0*/ x: kotlin.UShort): kotlin.String
+public fun test(): kotlin.Unit
@@ -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
@@ -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() {
+    takeUInt(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1 + 2<!>)
+    takeUInt(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1.plus(2)<!>)
+    takeNullableUInt(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>4<!>)
+
+    takeUInt(<!TYPE_MISMATCH!>Int.MAX_VALUE * 2L<!>)
+    takeUInt(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED, TYPE_MISMATCH!>-1<!>)
+    takeUInt(<!TYPE_MISMATCH!>Int.MAX_VALUE * 2L + 2<!>)
+
+    takeUByte(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>)
+    takeUByte(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>255<!>)
+    takeUByte(<!TYPE_MISMATCH!>1.toByte()<!>)
+
+    takeUShort(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>)
+    takeUInt(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>)
+    takeULong(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>)
+
+    takeULong(<!INT_LITERAL_OUT_OF_RANGE, TYPE_MISMATCH{NI}!>18446744073709551615<!>)
+    takeULong(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1844674407370955161<!>)
+    takeULong(18446744073709551615u)
+
+    takeUInt(<!INTEGER_OVERFLOW, TYPE_MISMATCH!>Int.MAX_VALUE * 2<!>)
+    takeUInt(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>4294967294<!>)
+
+    takeUBytes(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>2<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>255<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH, SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>256<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>0<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED, TYPE_MISMATCH!>-1<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>40 + 2<!>)
+
+    takeUInt(<!TYPE_MISMATCH!>1.myPlus(2)<!>)
+
+    val localVariable = 42
+    takeUInt(<!TYPE_MISMATCH!>localVariable<!>)
+
+    var localMutableVariable = 42
+    takeUInt(<!TYPE_MISMATCH!>localMutableVariable<!>)
+
+    val localNegativeVariable = -1
+    takeUInt(<!TYPE_MISMATCH!>localNegativeVariable<!>)
+
+    takeUInt(<!TYPE_MISMATCH!>globalVariable<!>)
+
+    takeUInt(<!TYPE_MISMATCH!>constVal<!>)
+
+    takeUInt(<!TYPE_MISMATCH!>globalVariableWithGetter<!>)
+}
+
+val globalVariable = 10
+
+const val constVal = 10
+
+val globalVariableWithGetter: Int get() = 0
+
+val prop: UByte = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>255<!>
+
+fun Int.myPlus(other: Int): Int = this + other
@@ -0,0 +1,14 @@
+package
+
+public const val constVal: kotlin.Int = 10
+public val globalVariable: kotlin.Int = 10
+public val globalVariableWithGetter: kotlin.Int
+public val prop: kotlin.UByte = 255
+public fun takeNullableUInt(/*0*/ u: kotlin.UInt?): kotlin.Unit
+public fun takeUByte(/*0*/ u: kotlin.UByte): kotlin.Unit
+public fun takeUBytes(/*0*/ vararg u: kotlin.UByte /*kotlin.UByteArray*/): kotlin.Unit
+public fun takeUInt(/*0*/ u: kotlin.UInt): kotlin.Unit
+public fun takeULong(/*0*/ u: kotlin.ULong): kotlin.Unit
+public fun takeUShort(/*0*/ u: kotlin.UShort): kotlin.Unit
+public fun test(): kotlin.Unit
+public fun kotlin.Int.myPlus(/*0*/ other: kotlin.Int): kotlin.Int
@@ -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)
+}
@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+val a0: Int = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1uL<!>
+val a1: UInt = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1uL<!>
+val a3: ULong = 1uL
+val a4 = 1UL + 2UL
+val a5 = <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>-<!>1UL
+
+fun takeULong(u: ULong) {}
+
+fun test() {
+    takeULong(3UL)
+    takeULong(1UL + 3uL)
+    takeULong(1u + 0uL)
+    takeULong(1uL + 4u)
+}
@@ -0,0 +1,9 @@
+package
+
+public val a0: kotlin.Int = 1.toULong()
+public val a1: kotlin.UInt = 1.toULong()
+public val a3: kotlin.ULong = 1.toULong()
+public val a4: kotlin.ULong
+public val a5: [ERROR : Type for -1UL]
+public fun takeULong(/*0*/ u: kotlin.ULong): kotlin.Unit
+public fun test(): kotlin.Unit
@@ -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
+}
@@ -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 = <!FORBIDDEN_IDENTITY_EQUALS!>ub1 === ub2<!> || <!FORBIDDEN_IDENTITY_EQUALS!>ub1 !== ub2<!>
+    val us = <!FORBIDDEN_IDENTITY_EQUALS!>us1 === us2<!> || <!FORBIDDEN_IDENTITY_EQUALS!>us1 !== us2<!>
+    val ui = <!FORBIDDEN_IDENTITY_EQUALS!>ui1 === ui2<!> || <!FORBIDDEN_IDENTITY_EQUALS!>ui1 !== ui2<!>
+    val ul = <!FORBIDDEN_IDENTITY_EQUALS!>ul1 === ul2<!> || <!FORBIDDEN_IDENTITY_EQUALS!>ul1 !== ul2<!>
+
+    val u = <!EQUALITY_NOT_APPLICABLE, FORBIDDEN_IDENTITY_EQUALS!>ub1 === ul1<!>
+
+    val a1 = <!FORBIDDEN_IDENTITY_EQUALS!>1u === 2u<!> || <!FORBIDDEN_IDENTITY_EQUALS!>1u !== 2u<!>
+    val a2 = <!FORBIDDEN_IDENTITY_EQUALS!>0xFFFF_FFFF_FFFF_FFFFu === 0xFFFF_FFFF_FFFF_FFFFu<!>
+
+    val bu1 = 1u
+    val bu2 = 1u
+
+    val c1 = <!FORBIDDEN_IDENTITY_EQUALS!>bu1 === bu2<!> || <!FORBIDDEN_IDENTITY_EQUALS!>bu1 !== bu2<!>
+}
@@ -0,0 +1,3 @@
+package
+
+public fun test(/*0*/ ub1: kotlin.UByte, /*1*/ ub2: kotlin.UByte, /*2*/ us1: kotlin.UShort, /*3*/ us2: kotlin.UShort, /*4*/ ui1: kotlin.UInt, /*5*/ ui2: kotlin.UInt, /*6*/ ul1: kotlin.ULong, /*7*/ ul2: kotlin.ULong): kotlin.Unit
@@ -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
+}
@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+<!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> var a: UInt
+
+fun foo() {
+    <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> var b: UByte
+    <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> var c: UShort
+    <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> var d: ULong
+}
@@ -0,0 +1,4 @@
+package
+
+public lateinit var a: kotlin.UInt
+public fun foo(): kotlin.Unit
@@ -0,0 +1,7 @@
+// FIR_IDENTICAL
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun test() {
+    val x: UInt = 1u + 2u
+    val y = 2u + 3u
+}
@@ -0,0 +1,3 @@
+package
+
+public fun test(): kotlin.Unit
@@ -0,0 +1,15 @@
+// FIR_IDENTICAL
+
+const val u0 = 1u
+const val u1: UByte = 2u
+const val u2: UShort = 3u
+const val u3: UInt = 3u
+const val u4: ULong = 4u
+
+const val u5 = 1U
+const val u6: UByte = 0xFFU
+
+const val u7 = 1uL
+const val u8 = 1UL
+const val u9 = 1UL
+const val u10 = 0xFFFF_FFFF_FFFFuL
@@ -0,0 +1,13 @@
+package
+
+public const val u0: kotlin.UInt = 1.toUInt()
+public const val u1: kotlin.UByte = 2.toUByte()
+public const val u10: kotlin.ULong = 281474976710655.toULong()
+public const val u2: kotlin.UShort = 3.toUShort()
+public const val u3: kotlin.UInt = 3.toUInt()
+public const val u4: kotlin.ULong = 4.toULong()
+public const val u5: kotlin.UInt = 1.toUInt()
+public const val u6: kotlin.UByte = -1.toUByte()
+public const val u7: kotlin.ULong = 1.toULong()
+public const val u8: kotlin.ULong = 1.toULong()
+public const val u9: kotlin.ULong = 1.toULong()
@@ -0,0 +1,6 @@
+// !API_VERSION: 1.2
+
+val a = 0u
+val b = 1uL
+
+fun foo(u: UInt) {}
@@ -0,0 +1,6 @@
+// !API_VERSION: 1.2
+
+val a = <!UNSIGNED_LITERAL_WITHOUT_DECLARATIONS_ON_CLASSPATH!>0u<!>
+val b = <!UNSIGNED_LITERAL_WITHOUT_DECLARATIONS_ON_CLASSPATH!>1uL<!>
+
+fun foo(<!UNUSED_PARAMETER!>u<!>: <!UNRESOLVED_REFERENCE!>UInt<!>) {}
@@ -0,0 +1,5 @@
+package
+
+public val a: [ERROR : Type cannot be resolved. Please make sure you have the required dependencies for unsigned types in the classpath]
+public val b: [ERROR : Type cannot be resolved. Please make sure you have the required dependencies for unsigned types in the classpath]
+public fun foo(/*0*/ u: [ERROR : UInt]): kotlin.Unit
@@ -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<!>
@@ -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 = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>256u<!>
+val s2 = <!INT_LITERAL_OUT_OF_RANGE!>18446744073709551616u<!>
@@ -0,0 +1,15 @@
+package
+
+public val s1: kotlin.UByte = 256.toUInt()
+public val s2: kotlin.Int
+public const val u1: kotlin.UByte = -1.toUByte()
+public const val u2: kotlin.UShort = -1.toUShort()
+public const val u3: kotlin.UInt = -1.toUInt()
+public const val u4: kotlin.ULong = -1.toULong()
+public const val u5: kotlin.ULong = -1.toULong()
+public const val u6: kotlin.ULong = -1.toULong()
+public const val u7: kotlin.ULong = -1.toULong()
+public val u8: kotlin.Comparable<*>
+public const val u9: kotlin.ULong = -1.toULong()
+public fun takeUByte(/*0*/ ubyte: kotlin.UByte): kotlin.Unit
+public fun test(): kotlin.Unit
@@ -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
@@ -0,0 +1,23 @@
+
+val a0: Any = 1u
+
+val n0: Number = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>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 = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1u<!>
+
+val m0 = <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>-<!>1u
+val m1: UInt = <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>-<!>1u
+
+val h1 = 0xFFu
+val h2: UShort = 0xFFu
+
+val b1 = 0b11u
+val b2: UByte = 0b11u
@@ -0,0 +1,17 @@
+package
+
+public val a0: kotlin.Any = 1.toUInt()
+public val b1: kotlin.UInt = 3.toUInt()
+public val b2: kotlin.UByte = 3.toUByte()
+public val c0: kotlin.Comparable<*>
+public val c1: kotlin.Comparable<kotlin.UInt>
+public val h1: kotlin.UInt = 255.toUInt()
+public val h2: kotlin.UShort = 255.toUShort()
+public val i0: kotlin.Int = 1.toUInt()
+public val m0: [ERROR : Type for -1u]
+public val m1: kotlin.UInt
+public val n0: kotlin.Number = 1.toUInt()
+public val u0: kotlin.UInt = 1.toUInt()
+public val u1: kotlin.UInt? = 1.toUInt()
+public val u2: kotlin.UInt? = 1.toUInt()
+public val u3: kotlin.UInt? = 1.toUInt()
@@ -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
@@ -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 = <!TYPE_MISMATCH!>a<!>
@@ -0,0 +1,7 @@
+package
+
+public fun rawUInt(/*0*/ vararg a: kotlin.UInt /*kotlin.UIntArray*/): kotlin.IntArray
+public fun ubyte(/*0*/ vararg a: kotlin.UByte /*kotlin.UByteArray*/): kotlin.UByteArray
+public fun uint(/*0*/ vararg a: kotlin.UInt /*kotlin.UIntArray*/): kotlin.UIntArray
+public fun ulong(/*0*/ vararg a: kotlin.ULong /*kotlin.ULongArray*/): kotlin.ULongArray
+public fun ushort(/*0*/ vararg a: kotlin.UShort /*kotlin.UShortArray*/): kotlin.UShortArray
@@ -0,0 +1,4 @@
+val a1 = 1ul
+val a2 = 0x1ul
+val a3 = 0B1ul
+val a4 = 1Ul
@@ -0,0 +1,4 @@
+val a1 = 1u<!WRONG_LONG_SUFFIX!>l<!>
+val a2 = 0x1u<!WRONG_LONG_SUFFIX!>l<!>
+val a3 = 0B1u<!WRONG_LONG_SUFFIX!>l<!>
+val a4 = 1U<!WRONG_LONG_SUFFIX!>l<!>
@@ -0,0 +1,6 @@
+package
+
+public val a1: kotlin.ULong = 1.toULong()
+public val a2: kotlin.ULong = 1.toULong()
+public val a3: kotlin.ULong = 1.toULong()
+public val a4: kotlin.ULong = 1.toULong()
				`@@ -0,0 +1 @@`
				`val foo = <!INAPPLICABLE_CANDIDATE!>UInt<!>()`
				`@@ -0,0 +1 @@`
				`val foo = <!INVISIBLE_MEMBER!>UInt<!>(<!NO_VALUE_FOR_PARAMETER!>)<!>`