Add spec tests for integer literals
This commit is contained in:
victor.petukhov
+99
@@ -0,0 +1,99 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Sequences with binary digit symbols.
|
||||
*/
|
||||
|
||||
val value_1 = 0b1110001100
|
||||
val value_2 = 0B11000110
|
||||
val value_3 = 0b100011
|
||||
val value_7 = 0B1000
|
||||
val value_8 = 0b110001
|
||||
val value_9 = 0b01100011
|
||||
|
||||
val value_10 = 0B0
|
||||
val value_11 = 0b1
|
||||
|
||||
val value_12 = 0b100000
|
||||
val value_13 = 0B1000001
|
||||
|
||||
val value_14 = 0B0000000
|
||||
val value_16 = 0b00000010
|
||||
|
||||
val value_17 = 0b001101
|
||||
val value_18 = 0B001101
|
||||
val value_19 = 0b0011
|
||||
val value_23 = 0B00000000
|
||||
val value_24 = 0b111
|
||||
val value_25 = 0b01111111110
|
||||
|
||||
val value_26 = 0b0111000110001101
|
||||
val value_27 = 0b0111000110001101
|
||||
val value_28 = 0B000000
|
||||
val value_29 = 0b011101
|
||||
val value_30 = 0b00
|
||||
val value_31 = 0B01
|
||||
val value_32 = 0b010010010000
|
||||
val value_33 = 0B000000000000
|
||||
val value_34 = 0b111001
|
||||
|
||||
fun box(): String? {
|
||||
val value_4 = 0B0001
|
||||
val value_5 = 0B00
|
||||
val value_6 = 0b00
|
||||
val value_15 = 0b0000001000000
|
||||
val value_20 = 0B0
|
||||
val value_21 = 0b0
|
||||
val value_22 = 0b00000000
|
||||
val value_35 = 0b011110000111110
|
||||
val value_36 = 0B00000000
|
||||
val value_37 = 0b00000000
|
||||
val value_38 = 0b000000010000000
|
||||
val value_39 = 0b000
|
||||
|
||||
if (value_1 != 0b1110001100 || value_1 != 908) return null
|
||||
if (value_2 != 0B11000110 || value_2 != 198) return null
|
||||
if (value_3 != 0b100011 || value_3 != 35) return null
|
||||
if (value_4 != 0B0001 || value_4 != 1) return null
|
||||
if (value_5 != 0B00 || value_5 != 0) return null
|
||||
if (value_6 != 0b00 || value_6 != 0) return null
|
||||
if (value_7 != 0B1000 || value_7 != 8) return null
|
||||
if (value_8 != 0b110001 || value_8 != 49) return null
|
||||
if (value_9 != 0b01100011 || value_9 != 99) return null
|
||||
if (value_10 != 0B0 || value_10 != 0) return null
|
||||
if (value_11 != 0b1 || value_11 != 1) return null
|
||||
if (value_12 != 0b100000 || value_12 != 32) return null
|
||||
if (value_13 != 0B1000001 || value_13 != 65) return null
|
||||
if (value_14 != 0B0000000 || value_14 != 0) return null
|
||||
if (value_15 != 0b0000001000000 || value_15 != 64) return null
|
||||
if (value_16 != 0b00000010 || value_16 != 2) return null
|
||||
if (value_17 != 0b001101 || value_17 != 13) return null
|
||||
if (value_18 != 0B001101 || value_18 != 13) return null
|
||||
if (value_19 != 0b0011 || value_19 != 3) return null
|
||||
if (value_20 != 0B0 || value_20 != 0) return null
|
||||
if (value_21 != 0b0 || value_21 != 0) return null
|
||||
if (value_22 != 0b00000000 || value_22 != 0) return null
|
||||
if (value_23 != 0B00000000 || value_23 != 0) return null
|
||||
if (value_24 != 0b111 || value_24 != 7) return null
|
||||
if (value_25 != 0b01111111110 || value_25 != 1022) return null
|
||||
if (value_26 != 0b0111000110001101 || value_26 != 29069) return null
|
||||
if (value_27 != 0b0111000110001101 || value_27 != 29069) return null
|
||||
if (value_28 != 0B000000 || value_28 != 0) return null
|
||||
if (value_29 != 0b011101 || value_29 != 29) return null
|
||||
if (value_30 != 0b00 || value_30 != 0) return null
|
||||
if (value_31 != 0B01 || value_31 != 1) return null
|
||||
if (value_32 != 0b010010010000 || value_32 != 1168) return null
|
||||
if (value_33 != 0B000000000000 || value_33 != 0) return null
|
||||
if (value_34 != 0b111001 || value_34 != 57) return null
|
||||
if (value_35 != 0b011110000111110 || value_35 != 15422) return null
|
||||
if (value_36 != 0B00000000 || value_36 != 0) return null
|
||||
if (value_37 != 0b00000000 || value_37 != 0) return null
|
||||
if (value_38 != 0b000000010000000 || value_38 != 128) return null
|
||||
if (value_39 != 0b000 || value_39 != 0) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Sequences with binary digit symbols separated by underscores.
|
||||
*/
|
||||
|
||||
val value_1 = 0b1_110110100
|
||||
val value_2 = 0b1_______1011010
|
||||
val value_3 = 0b1_0_1_1_0_1
|
||||
val value_4 = 0b0_______1_______1_______0
|
||||
val value_5 = 0b1__________________________________________________________________________________________________1
|
||||
val value_6 = 0b0_______0
|
||||
|
||||
fun box(): String? {
|
||||
val value_7 = 0B0_0
|
||||
val value_8 = 0b1_______________________________________________________________________________________________________________________________________________________0
|
||||
val value_9 = 0b1_00000000000000_1
|
||||
|
||||
if (value_1 != 0b1110110100 || value_1 != 0B1_110110100 || value_1 != 948) return null
|
||||
if (value_2 != 0b11011010 || value_2 != 0b1_______1011010 || value_2 != 218) return null
|
||||
if (value_3 != 0b101101 || value_3 != 0b1_0_1_1_0_1 || value_3 != 45) return null
|
||||
if (value_4 != 0b0110 || value_4 != 0B0_______1_______1_______0 || value_4 != 6) return null
|
||||
if (value_5 != 0b11 || value_5 != 0b1__________________________________________________________________________________________________1 || value_5 != 3) return null
|
||||
if (value_6 != 0b0_______0 || value_6 != 0b00 || value_6 != 0b0 || value_6 != 0) return null
|
||||
if (value_7 != 0b0_0 || value_7 != 0b00 || value_7 != 0b0 || value_7 != 0) return null
|
||||
if (value_8 != 0b10 || value_8 != 0B1_______________________________________________________________________________________________________________________________________________________0 || value_8 != 2) return null
|
||||
if (value_9 != 0b1000000000000001 || value_9 != 0B1_00000000000000_1 || value_9 != 32769) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Sequences with decimal digit symbols.
|
||||
*/
|
||||
|
||||
val value_1 = 1234567890
|
||||
val value_2 = 23456789
|
||||
val value_3 = 345678
|
||||
val value_4 = 4567
|
||||
val value_5 = 56
|
||||
val value_6 = 65
|
||||
val value_7 = 7654
|
||||
val value_8 = 876543
|
||||
val value_9 = 98765432
|
||||
|
||||
fun box(): String? {
|
||||
val value_10 = 0
|
||||
val value_11 = 1
|
||||
val value_12 = 100000
|
||||
val value_13 = 1000001
|
||||
|
||||
if (value_1 != 1234567890) return null
|
||||
if (value_2 != 23456789) return null
|
||||
if (value_3 != 345678) return null
|
||||
if (value_4 != 4567) return null
|
||||
if (value_5 != 56) return null
|
||||
if (value_6 != 65) return null
|
||||
if (value_7 != 7654) return null
|
||||
if (value_8 != 876543) return null
|
||||
if (value_9 != 98765432) return null
|
||||
if (value_10 != 0) return null
|
||||
if (value_11 != 1) return null
|
||||
if (value_12 != 100000) return null
|
||||
if (value_13 != 1000001) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Sequences with decimal digit symbols separated by underscores.
|
||||
*/
|
||||
|
||||
val value_1 = 1234_5678_90
|
||||
val value_2 = 1_2_3_4_5_6_7_8_9_0
|
||||
val value_3 = 1_2
|
||||
val value_4 = 1_00000000000000000_1
|
||||
val value_5 = 1_____________2
|
||||
|
||||
fun box(): String? {
|
||||
val value_6 = 9_____________0000
|
||||
val value_7 = 9____________0_0000
|
||||
val value_8 = 1_______________________________________________________________________________________________________________________________________________________0
|
||||
|
||||
if (value_1 != 1234_5678_90 || value_1 != 1234567890) return null
|
||||
if (value_2 != 1_2_3_4_5_6_7_8_9_0 || value_2 != 1234567890) return null
|
||||
if (value_3 != 1_2 || value_3 != 12) return null
|
||||
if (value_4 != 1_00000000000000000_1 || value_4 != 1000000000000000001) return null
|
||||
if (value_5 != 1_____________2 || value_5 != 12) return null
|
||||
if (value_6 != 9_____________0000 || value_6 != 90000) return null
|
||||
if (value_7 != 9____________0_0000 || value_7 != 900000) return null
|
||||
if (value_8 != 1_______________________________________________________________________________________________________________________________________________________0 || value_8 != 10) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+99
@@ -0,0 +1,99 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Sequences with hexadecimal digit symbols.
|
||||
*/
|
||||
|
||||
val value_1 = 0x1234567890
|
||||
val value_2 = 0X23456789
|
||||
val value_3 = 0x345678
|
||||
val value_7 = 0X7654
|
||||
val value_8 = 0x876543
|
||||
val value_9 = 0x98765432
|
||||
|
||||
val value_10 = 0X0
|
||||
val value_11 = 0x1
|
||||
|
||||
val value_12 = 0x100000
|
||||
val value_13 = 0X1000001
|
||||
|
||||
val value_14 = 0X0000000
|
||||
val value_16 = 0x00000010
|
||||
|
||||
val value_17 = 0xABCDEF
|
||||
val value_18 = 0Xabcdef
|
||||
val value_19 = 0xAbcD
|
||||
val value_23 = 0XAAAAAAAA
|
||||
val value_24 = 0xcDf
|
||||
val value_25 = 0xAcccccccccA
|
||||
|
||||
val value_26 = 0x0123456789ABCDEF
|
||||
val value_27 = 0x0123456789abcdef
|
||||
val value_28 = 0XAA00AA
|
||||
val value_29 = 0xBc12eF
|
||||
val value_30 = 0xa0
|
||||
val value_31 = 0XE1
|
||||
val value_32 = 0xE1eE2eE3eE4e
|
||||
val value_33 = 0XAAAAAA000000
|
||||
val value_34 = 0xcDf091
|
||||
|
||||
fun box(): String? {
|
||||
val value_4 = 0X4567
|
||||
val value_5 = 0X56
|
||||
val value_6 = 0x65
|
||||
val value_15 = 0x0000001000000
|
||||
val value_20 = 0Xa
|
||||
val value_21 = 0xE
|
||||
val value_22 = 0xEeEeEeEe
|
||||
val value_35 = 0xAcccc0000cccccA
|
||||
val value_36 = 0X0000000A
|
||||
val value_37 = 0xe0000000
|
||||
val value_38 = 0x0000000D0000000
|
||||
val value_39 = 0xA0A
|
||||
|
||||
if (value_1 != 0x1234567890 || value_1 != 78187493520) return null
|
||||
if (value_2 != 0X23456789 || value_2 != 591751049) return null
|
||||
if (value_3 != 0x345678 || value_3 != 3430008) return null
|
||||
if (value_4 != 0X4567 || value_4 != 17767) return null
|
||||
if (value_5 != 0X56 || value_5 != 86) return null
|
||||
if (value_6 != 0x65 || value_6 != 101) return null
|
||||
if (value_7 != 0X7654 || value_7 != 30292) return null
|
||||
if (value_8 != 0x876543 || value_8 != 8873283) return null
|
||||
if (value_9 != 0x98765432 || value_9 != 2557891634) return null
|
||||
if (value_10 != 0X0 || value_10 != 0) return null
|
||||
if (value_11 != 0x1 || value_11 != 1) return null
|
||||
if (value_12 != 0x100000 || value_12 != 1048576) return null
|
||||
if (value_13 != 0X1000001 || value_13 != 16777217) return null
|
||||
if (value_14 != 0X0000000 || value_14 != 0) return null
|
||||
if (value_15 != 0x0000001000000 || value_15 != 16777216) return null
|
||||
if (value_16 != 0x00000010 || value_16 != 16) return null
|
||||
if (value_17 != 0xABCDEF || value_17 != 11259375) return null
|
||||
if (value_18 != 0Xabcdef || value_18 != 11259375) return null
|
||||
if (value_19 != 0xAbcD || value_19 != 43981) return null
|
||||
if (value_20 != 0Xa || value_20 != 10) return null
|
||||
if (value_21 != 0xE || value_21 != 14) return null
|
||||
if (value_22 != 0xEeEeEeEe || value_22 != 4008636142) return null
|
||||
if (value_23 != 0XAAAAAAAA || value_23 != 2863311530) return null
|
||||
if (value_24 != 0xcDf || value_24 != 3295) return null
|
||||
if (value_25 != 0xAcccccccccA || value_25 != 11874725579978) return null
|
||||
if (value_26 != 0x0123456789ABCDEF || value_26 != 81985529216486895) return null
|
||||
if (value_27 != 0x0123456789abcdef || value_27 != 81985529216486895) return null
|
||||
if (value_28 != 0XAA00AA || value_28 != 11141290) return null
|
||||
if (value_29 != 0xBc12eF || value_29 != 12325615) return null
|
||||
if (value_30 != 0xa0 || value_30 != 160) return null
|
||||
if (value_31 != 0XE1 || value_31 != 225) return null
|
||||
if (value_32 != 0xE1eE2eE3eE4e || value_32 != 248413105155662) return null
|
||||
if (value_33 != 0XAAAAAA000000 || value_33 != 187649973288960) return null
|
||||
if (value_34 != 0xcDf091 || value_34 != 13496465) return null
|
||||
if (value_35 != 0xAcccc0000cccccA || value_35 != 778221136013741258) return null
|
||||
if (value_36 != 0X0000000A || value_36 != 10) return null
|
||||
if (value_37 != 0xe0000000 || value_37 != 3758096384) return null
|
||||
if (value_38 != 0x0000000D0000000 || value_38 != 3489660928) return null
|
||||
if (value_39 != 0xA0A || value_39 != 2570) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Sequences with hexadecimal digit symbols separated by underscores.
|
||||
*/
|
||||
|
||||
val value_1 = 0x1_23a567b90
|
||||
val value_2 = 0XF_______34a6789f
|
||||
val value_3 = 0x3_c_c_c_7_8
|
||||
val value_4 = 0X4_______b_______6_______d
|
||||
val value_5 = 0X5__________________________________________________________________________________________________f
|
||||
val value_6 = 0x0_______0
|
||||
|
||||
fun box(): String? {
|
||||
val value_7 = 0X0_0
|
||||
val value_8 = 0xa_______________________________________________________________________________________________________________________________________________________0
|
||||
val value_9 = 0x1_00000000000000_1
|
||||
|
||||
if (value_1 != 0x123a567b90 || value_1 != 0x1_23a567b90 || value_1 != 78288157584) return null
|
||||
if (value_2 != 0XF34a6789f || value_2 != 0xF_______34a6789f || value_2 != 65307834527) return null
|
||||
if (value_3 != 0x3ccc78 || value_3 != 0x3_c_c_c_7_8 || value_3 != 3984504) return null
|
||||
if (value_4 != 0X4b6d || value_4 != 0x4_______b_______6_______d || value_4 != 19309) return null
|
||||
if (value_5 != 0X5f || value_5 != 0X5__________________________________________________________________________________________________f || value_5 != 95) return null
|
||||
if (value_6 != 0x0_______0 || value_6 != 0x00 || value_6 != 0x0 || value_6 != 0) return null
|
||||
if (value_7 != 0x0_0 || value_7 != 0X00 || value_7 != 0x0 || value_7 != 0) return null
|
||||
if (value_8 != 0xa0 || value_8 != 0xa_______________________________________________________________________________________________________________________________________________________0 || value_8 != 160) return null
|
||||
if (value_9 != 0x1000000000000001 || value_9 != 0X1_00000000000000_1 || value_9 != 1152921504606846977) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Decimal integer literals with long literal mark.
|
||||
*/
|
||||
|
||||
val value_1 = 0L
|
||||
|
||||
val value_2 = 127L
|
||||
val value_3 = 128L
|
||||
val value_4 = -128L
|
||||
val value_5 = -129L
|
||||
|
||||
val value_6 = 32767L
|
||||
val value_7 = 32768L
|
||||
val value_8 = -32768L
|
||||
val value_9 = -32769L
|
||||
|
||||
val value_10 = 2147483647L
|
||||
val value_11 = 2147483648L
|
||||
val value_12 = -2147483648L
|
||||
val value_13 = -2147483649L
|
||||
|
||||
fun box(): String? {
|
||||
val value_14 = 9223372036854775807L
|
||||
val value_15 = -9223372036854775807L
|
||||
|
||||
if (value_1 != 0L) return null
|
||||
if (value_2 != 127L) return null
|
||||
if (value_3 != 128L) return null
|
||||
if (value_4 != -128L) return null
|
||||
if (value_5 != -129L) return null
|
||||
if (value_6 != 32767L) return null
|
||||
if (value_7 != 32768L) return null
|
||||
if (value_8 != -32768L) return null
|
||||
if (value_9 != -32769L) return null
|
||||
if (value_10 != 2147483647L) return null
|
||||
if (value_11 != 2147483648L) return null
|
||||
if (value_12 != -2147483648L) return null
|
||||
if (value_13 != -2147483649L) return null
|
||||
if (value_14 != 9223372036854775807L) return null
|
||||
if (value_15 != -9223372036854775807L) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Hexadecimal integer literals with long literal mark.
|
||||
*/
|
||||
|
||||
val value_1 = 0x0L
|
||||
|
||||
val value_2 = 0x7FL
|
||||
val value_3 = 0X80L
|
||||
val value_4 = -0X80L
|
||||
val value_5 = -0x81L
|
||||
|
||||
val value_6 = 0x7FFFL
|
||||
val value_7 = 0x8000L
|
||||
val value_8 = -0x8000L
|
||||
val value_9 = -0x8001L
|
||||
|
||||
val value_10 = 0x7FFFFFFFL
|
||||
val value_11 = 0x80000000L
|
||||
val value_12 = -0x80000000L
|
||||
val value_13 = -0x80000001L
|
||||
|
||||
fun box(): String? {
|
||||
val value_14 = 0X7FFFFFFFFFFFFFFFL
|
||||
val value_15 = -0X7FFFFFFFFFFFFFFFL
|
||||
|
||||
if (value_1 != 0x0L) return null
|
||||
if (value_2 != 0x7FL) return null
|
||||
if (value_3 != 0X80L) return null
|
||||
if (value_4 != -0X80L) return null
|
||||
if (value_5 != -0x81L) return null
|
||||
if (value_6 != 0x7FFFL) return null
|
||||
if (value_7 != 0x8000L) return null
|
||||
if (value_8 != -0x8000L) return null
|
||||
if (value_9 != -0x8001L) return null
|
||||
if (value_10 != 0x7FFFFFFFL) return null
|
||||
if (value_11 != 0x80000000L) return null
|
||||
if (value_12 != -0x80000000L) return null
|
||||
if (value_13 != -0x80000001L) return null
|
||||
if (value_14 != 0X7FFFFFFFFFFFFFFFL) return null
|
||||
if (value_15 != -0X7FFFFFFFFFFFFFFFL) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
KOTLIN CODEGEN BOX SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Binary integer literals with long literal mark.
|
||||
*/
|
||||
|
||||
val value_1 = 0b0L
|
||||
|
||||
val value_2 = 0B1111111L
|
||||
val value_3 = 0b10000000L
|
||||
val value_4 = -0b10000000L
|
||||
val value_5 = -0b10000001L
|
||||
|
||||
val value_6 = 0B111111111111111L
|
||||
val value_7 = 0b1000000000000000L
|
||||
val value_8 = -0b1000000000000000L
|
||||
val value_9 = -0b1000000000000001L
|
||||
|
||||
val value_10 = 0b1111111111111111111111111111111L
|
||||
val value_11 = 0B10000000000000000000000000000000L
|
||||
val value_12 = -0B10000000000000000000000000000000L
|
||||
val value_13 = -0b10000000000000000000000000000001L
|
||||
|
||||
fun box(): String? {
|
||||
val value_14 = 0X7FFFFFFFFFFFFFFFL
|
||||
val value_15 = -0X7FFFFFFFFFFFFFFFL
|
||||
|
||||
if (value_1 != 0b0L) return null
|
||||
if (value_2 != 0B1111111L) return null
|
||||
if (value_3 != 0b10000000L) return null
|
||||
if (value_4 != -0b10000000L) return null
|
||||
if (value_5 != -0b10000001L) return null
|
||||
if (value_6 != 0B111111111111111L) return null
|
||||
if (value_7 != 0b1000000000000000L) return null
|
||||
if (value_8 != -0b1000000000000000L) return null
|
||||
if (value_9 != -0b1000000000000001L) return null
|
||||
if (value_10 != 0b1111111111111111111111111111111L) return null
|
||||
if (value_11 != 0B10000000000000000000000000000000L) return null
|
||||
if (value_12 != -0B10000000000000000000000000000000L) return null
|
||||
if (value_13 != -0b10000000000000000000000000000001L) return null
|
||||
if (value_14 != 0b111111111111111111111111111111111111111111111111111111111111111L) return null
|
||||
if (value_15 != -0B111111111111111111111111111111111111111111111111111111111111111L) return null
|
||||
|
||||
return "OK"
|
||||
}
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of binary digit symbols (0 or 1) prefixed by 0b or 0B is a binary integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Binary integer literals with the prefix only.
|
||||
*/
|
||||
|
||||
val value_1 = <!INT_LITERAL_OUT_OF_RANGE!>0b<!>
|
||||
val value_2 = <!INT_LITERAL_OUT_OF_RANGE!>0B<!>
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Int
|
||||
public val value_2: kotlin.Int
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Binary integer literals with an underscore after the prefix.
|
||||
*/
|
||||
|
||||
val value_1 = <!ILLEGAL_UNDERSCORE!>0b_1110100000<!>
|
||||
val value_2 = <!ILLEGAL_UNDERSCORE!>0B_______11010000<!>
|
||||
val value_3 = <!ILLEGAL_UNDERSCORE!>0B_1_1_0_1_0_0_0_0<!>
|
||||
val value_4 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0b_<!>
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Int = 928
|
||||
public val value_2: kotlin.Int = 208
|
||||
public val value_3: kotlin.Int = 208
|
||||
public val value_4: kotlin.Int
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Binary integer literals with an underscore in the first position (it's considered as identifiers).
|
||||
*/
|
||||
|
||||
val value_0 = <!UNRESOLVED_REFERENCE!>_____0b0_1_1_1_0_1<!>
|
||||
val value_1 = <!UNRESOLVED_REFERENCE!>_0B1_______1_______1_______0<!>
|
||||
val value_2 = <!UNRESOLVED_REFERENCE!>_0_0B1_0_1_1_1_0_1_1<!>
|
||||
val value_3 = <!UNRESOLVED_REFERENCE!>_0B000000000<!>
|
||||
val value_4 = <!UNRESOLVED_REFERENCE!>_0000000000b<!>
|
||||
val value_5 = <!UNRESOLVED_REFERENCE!>_0_1b<!>
|
||||
val value_6 = <!UNRESOLVED_REFERENCE!>____________0b<!>
|
||||
val value_7 = <!UNRESOLVED_REFERENCE!>_0_b_0<!>
|
||||
val value_8 = <!UNRESOLVED_REFERENCE!>_b_0<!>
|
||||
val value_9 = <!UNRESOLVED_REFERENCE!>_b<!>
|
||||
val value_10 = <!UNRESOLVED_REFERENCE!>_b_<!>
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
package
|
||||
|
||||
public val value_0: [ERROR : Type for _____0b0_1_1_1_0_1]
|
||||
public val value_1: [ERROR : Type for _0B1_______1_______1_______0]
|
||||
public val value_10: [ERROR : Type for _b_]
|
||||
public val value_2: [ERROR : Type for _0_0B1_0_1_1_1_0_1_1]
|
||||
public val value_3: [ERROR : Type for _0B000000000]
|
||||
public val value_4: [ERROR : Type for _0000000000b]
|
||||
public val value_5: [ERROR : Type for _0_1b]
|
||||
public val value_6: [ERROR : Type for ____________0b]
|
||||
public val value_7: [ERROR : Type for _0_b_0]
|
||||
public val value_8: [ERROR : Type for _b_0]
|
||||
public val value_9: [ERROR : Type for _b]
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Binary integer literals with an underscore in the last position.
|
||||
*/
|
||||
|
||||
val value_1 = <!ILLEGAL_UNDERSCORE!>0b0_1_1_0_1_1_____<!>
|
||||
val value_2 = <!ILLEGAL_UNDERSCORE!>0B1_______1_______0_______1_<!>
|
||||
val value_3 = <!ILLEGAL_UNDERSCORE!>0B000000000_<!>
|
||||
val value_4 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0b_<!>
|
||||
val value_5 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0B______________<!>
|
||||
val value_6 = <!ILLEGAL_UNDERSCORE!>0B0_<!>
|
||||
val value_7 = <!ILLEGAL_UNDERSCORE!>0B10_<!>
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Int = 27
|
||||
public val value_2: kotlin.Int = 13
|
||||
public val value_3: kotlin.Int = 0
|
||||
public val value_4: kotlin.Int
|
||||
public val value_5: kotlin.Int
|
||||
public val value_6: kotlin.Int = 0
|
||||
public val value_7: kotlin.Int = 2
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Integer literals with an underscore in the last position.
|
||||
*/
|
||||
|
||||
val value_1 = <!ILLEGAL_UNDERSCORE!>1_<!>
|
||||
val value_2 = <!ILLEGAL_UNDERSCORE!>1_00000000000000000_<!>
|
||||
val value_3 = <!ILLEGAL_UNDERSCORE!>1_____________<!>
|
||||
val value_4 = <!ILLEGAL_UNDERSCORE!>9____________0_<!>
|
||||
val value_5 = <!ILLEGAL_UNDERSCORE!>1_______________________________________________________________________________________________________________________________________________________<!>
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Int = 1
|
||||
public val value_2: kotlin.Long = 100000000000000000.toLong()
|
||||
public val value_3: kotlin.Int = 1
|
||||
public val value_4: kotlin.Int = 90
|
||||
public val value_5: kotlin.Int = 1
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Integer literals with an underscore in the first position (it's considered as identifiers).
|
||||
*/
|
||||
|
||||
val value_1 = <!UNRESOLVED_REFERENCE!>_5678_90<!>
|
||||
val value_2 = <!UNRESOLVED_REFERENCE!>_2_3_4_5_6_7_8_9_<!>
|
||||
val value_3 = <!UNRESOLVED_REFERENCE!>_____________0000<!>
|
||||
val value_4 = <!UNRESOLVED_REFERENCE!>_______________________________________________________________________________________________________________________________________________________0<!>
|
||||
val value_5 = <!UNRESOLVED_REFERENCE!>____________________________________________________<!>
|
||||
val value_6 = <!UNRESOLVED_REFERENCE!>_<!>
|
||||
val value_7 = <!UNRESOLVED_REFERENCE!>_0_<!>
|
||||
val value_8 = <!UNRESOLVED_REFERENCE!>_9_<!>
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
package
|
||||
|
||||
public val value_1: [ERROR : Type for _5678_90]
|
||||
public val value_2: [ERROR : Type for _2_3_4_5_6_7_8_9_]
|
||||
public val value_3: [ERROR : Type for _____________0000]
|
||||
public val value_4: [ERROR : Type for _______________________________________________________________________________________________________________________________________________________0]
|
||||
public val value_5: [ERROR : Type for ____________________________________________________]
|
||||
public val value_6: [ERROR : Type for _]
|
||||
public val value_7: [ERROR : Type for _0_]
|
||||
public val value_8: [ERROR : Type for _9_]
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of hexadecimal digit symbols (0 through 9, a through f, A through F) prefixed by 0x or 0X is a hexadecimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Hexadecimal integer literals with the prefix only.
|
||||
*/
|
||||
|
||||
val value_1 = <!INT_LITERAL_OUT_OF_RANGE!>0x<!>
|
||||
val value_2 = <!INT_LITERAL_OUT_OF_RANGE!>0X<!>
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Int
|
||||
public val value_2: kotlin.Int
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Hexadecimal integer literals with an underscore after the prefix.
|
||||
*/
|
||||
|
||||
val value_1 = <!ILLEGAL_UNDERSCORE!>0x_1234567890<!>
|
||||
val value_2 = <!ILLEGAL_UNDERSCORE!>0X_______23456789<!>
|
||||
val value_3 = <!ILLEGAL_UNDERSCORE!>0X_2_3_4_5_6_7_8_9<!>
|
||||
val value_4 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0x_<!>
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Long = 78187493520.toLong()
|
||||
public val value_2: kotlin.Int = 591751049
|
||||
public val value_3: kotlin.Int = 591751049
|
||||
public val value_4: kotlin.Int
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Hexadecimal integer literals with an underscore in the first position (it's considered as identifiers).
|
||||
*/
|
||||
|
||||
val value_1 = <!UNRESOLVED_REFERENCE!>_____0x3_4_5_6_7_8<!>
|
||||
val value_2 = <!UNRESOLVED_REFERENCE!>_0X4_______5_______6_______7<!>
|
||||
val value_3 = <!UNRESOLVED_REFERENCE!>_0_0X4_3_4_5_6_7_8_9<!>
|
||||
val value_4 = <!UNRESOLVED_REFERENCE!>_0X000000000<!>
|
||||
val value_5 = <!UNRESOLVED_REFERENCE!>_0000000000x<!>
|
||||
val value_6 = <!UNRESOLVED_REFERENCE!>_0_9x<!>
|
||||
val value_7 = <!UNRESOLVED_REFERENCE!>____________0x<!>
|
||||
val value_8 = <!UNRESOLVED_REFERENCE!>_0_x_0<!>
|
||||
val value_9 = <!UNRESOLVED_REFERENCE!>_x_0<!>
|
||||
val value_10 = <!UNRESOLVED_REFERENCE!>_x<!>
|
||||
val value_11 = <!UNRESOLVED_REFERENCE!>_x_<!>
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
package
|
||||
|
||||
public val value_1: [ERROR : Type for _____0x3_4_5_6_7_8]
|
||||
public val value_10: [ERROR : Type for _x]
|
||||
public val value_11: [ERROR : Type for _x_]
|
||||
public val value_2: [ERROR : Type for _0X4_______5_______6_______7]
|
||||
public val value_3: [ERROR : Type for _0_0X4_3_4_5_6_7_8_9]
|
||||
public val value_4: [ERROR : Type for _0X000000000]
|
||||
public val value_5: [ERROR : Type for _0000000000x]
|
||||
public val value_6: [ERROR : Type for _0_9x]
|
||||
public val value_7: [ERROR : Type for ____________0x]
|
||||
public val value_8: [ERROR : Type for _0_x_0]
|
||||
public val value_9: [ERROR : Type for _x_0]
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] A sequence of hexadecimal digit symbols (0 through 9, a through f, A through F) prefixed by 0x or 0X is a hexadecimal integer literal.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Hexadecimal integer literals with an underscore in the last position.
|
||||
*/
|
||||
|
||||
val value_1 = <!ILLEGAL_UNDERSCORE!>0x3_4_5_6_7_8_____<!>
|
||||
val value_2 = <!ILLEGAL_UNDERSCORE!>0X4_______5_______6_______7_<!>
|
||||
val value_3 = <!ILLEGAL_UNDERSCORE!>0X000000000_<!>
|
||||
val value_5 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0x_<!>
|
||||
val value_6 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0X______________<!>
|
||||
val value_7 = <!ILLEGAL_UNDERSCORE!>0X0_<!>
|
||||
val value_8 = <!ILLEGAL_UNDERSCORE!>0X10_<!>
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Int = 3430008
|
||||
public val value_2: kotlin.Int = 17767
|
||||
public val value_3: kotlin.Int = 0
|
||||
public val value_5: kotlin.Int
|
||||
public val value_6: kotlin.Int
|
||||
public val value_7: kotlin.Int = 0
|
||||
public val value_8: kotlin.Int = 16
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] Any of the decimal, hexadecimal or binary literals may be suffixed by the long literal mark (symbol L).
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Binary and hexadecimal integer literals with a long literal mark only.
|
||||
*/
|
||||
|
||||
val value_1 = <!INT_LITERAL_OUT_OF_RANGE!>0bl<!>
|
||||
val value_2 = <!INT_LITERAL_OUT_OF_RANGE!>0BL<!>
|
||||
val value_3 = <!INT_LITERAL_OUT_OF_RANGE!>0Xl<!>
|
||||
val value_4 = <!INT_LITERAL_OUT_OF_RANGE!>0xL<!>
|
||||
|
||||
val value_5 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0b_l<!>
|
||||
val value_6 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0B_L<!>
|
||||
val value_7 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0X____l<!>
|
||||
val value_8 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0x_L<!>
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Int
|
||||
public val value_2: kotlin.Int
|
||||
public val value_3: kotlin.Int
|
||||
public val value_4: kotlin.Int
|
||||
public val value_5: kotlin.Int
|
||||
public val value_6: kotlin.Int
|
||||
public val value_7: kotlin.Int
|
||||
public val value_8: kotlin.Int
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] Any of the decimal, hexadecimal or binary literals may be suffixed by the long literal mark (symbol L).
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Various integer literals with a not allowed underscore before the long literal mark.
|
||||
*/
|
||||
|
||||
val value_1 = <!ILLEGAL_UNDERSCORE!>0b0_<!WRONG_LONG_SUFFIX!>l<!><!>
|
||||
val value_2 = <!ILLEGAL_UNDERSCORE, INT_LITERAL_OUT_OF_RANGE!>0B12_L<!>
|
||||
val value_3 = <!ILLEGAL_UNDERSCORE!>0X234_<!WRONG_LONG_SUFFIX!>l<!><!>
|
||||
val value_4 = <!ILLEGAL_UNDERSCORE!>0x3567_L<!>
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Long = 0.toLong()
|
||||
public val value_2: kotlin.Int
|
||||
public val value_3: kotlin.Long = 564.toLong()
|
||||
public val value_4: kotlin.Long = 13671.toLong()
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] Any of the decimal, hexadecimal or binary literals may be suffixed by the long literal mark (symbol L).
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Various integer literals with not allowed long literal mark in lower case.
|
||||
*/
|
||||
|
||||
val value_1 = 0<!WRONG_LONG_SUFFIX!>l<!>
|
||||
val value_2 = 1000000000000000<!WRONG_LONG_SUFFIX!>l<!>
|
||||
val value_3 = 0X0<!WRONG_LONG_SUFFIX!>l<!>
|
||||
val value_4 = 0b101<!WRONG_LONG_SUFFIX!>l<!>
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
package
|
||||
|
||||
public val value_1: kotlin.Long = 0.toLong()
|
||||
public val value_2: kotlin.Long = 1000000000000000.toLong()
|
||||
public val value_3: kotlin.Long = 0.toLong()
|
||||
public val value_4: kotlin.Long = 5.toLong()
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Various integer literals with not allowed long literal mark in lower case (type checking).
|
||||
*/
|
||||
|
||||
fun case_1() {
|
||||
0<!WRONG_LONG_SUFFIX!>l<!> checkType { _<Long>() }
|
||||
10000000000000<!WRONG_LONG_SUFFIX!>l<!> checkType { _<Long>() }
|
||||
0X000Af10cD<!WRONG_LONG_SUFFIX!>l<!> checkType { _<Long>() }
|
||||
0x0_0<!WRONG_LONG_SUFFIX!>l<!> checkType { _<Long>() }
|
||||
0b100_000_111_111<!WRONG_LONG_SUFFIX!>l<!> checkType { _<Long>() }
|
||||
0b0<!WRONG_LONG_SUFFIX!>l<!> checkType { _<Long>() }
|
||||
}
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Type checking (comparison with invalid types) of various integer literals with long literal mark.
|
||||
*/
|
||||
|
||||
fun case_1() {
|
||||
0L checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
1000000L checkType { <!TYPE_MISMATCH!>_<!><Int>() }
|
||||
0XAf10cDL checkType { <!TYPE_MISMATCH!>_<!><Int>() }
|
||||
0x0_0L checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
0b100_000_111_111L checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
0b0L checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
|
||||
checkSubtype<Short>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>0L<!>)
|
||||
checkSubtype<Int>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1000000L<!>)
|
||||
checkSubtype<Int>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>0XAf10cDL<!>)
|
||||
checkSubtype<Byte>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>0x0_0L<!>)
|
||||
checkSubtype<Short>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>0b100_000_111_111L<!>)
|
||||
checkSubtype<Byte>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>0b0L<!>)
|
||||
}
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Type checking (comparison with invalid types) of various integer literals.
|
||||
*/
|
||||
|
||||
fun case_1() {
|
||||
0 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
0 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
0 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
127 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
127 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
127 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>128<!>)
|
||||
128 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
128 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
128 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
-128 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
-128 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
-128 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!TYPE_MISMATCH!>-129<!>)
|
||||
-129 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
-129 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
-129 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>32767<!>)
|
||||
32767 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
32767 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
32767 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>32768<!>)
|
||||
checkSubtype<Short>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>32768<!>)
|
||||
32768 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
32768 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
32768 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!TYPE_MISMATCH!>-32768<!>)
|
||||
-32768 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
-32768 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
-32768 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!TYPE_MISMATCH!>-32769<!>)
|
||||
checkSubtype<Short>(<!TYPE_MISMATCH!>-32769<!>)
|
||||
-32769 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
-32769 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
-32769 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>2147483647<!>)
|
||||
checkSubtype<Short>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>2147483647<!>)
|
||||
2147483647 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
2147483647 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
2147483647 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>2147483648<!>)
|
||||
checkSubtype<Short>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>2147483648<!>)
|
||||
checkSubtype<Int>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>2147483648<!>)
|
||||
2147483648 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
2147483648 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
2147483648 checkType { <!TYPE_MISMATCH!>_<!><Int>() }
|
||||
|
||||
checkSubtype<Byte>(<!TYPE_MISMATCH!>-2147483648<!>)
|
||||
checkSubtype<Short>(<!TYPE_MISMATCH!>-2147483648<!>)
|
||||
-2147483648 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
-2147483648 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
-2147483648 checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Byte>(<!TYPE_MISMATCH!>-2147483649<!>)
|
||||
checkSubtype<Short>(<!TYPE_MISMATCH!>-2147483649<!>)
|
||||
checkSubtype<Int>(<!TYPE_MISMATCH!>-2147483649<!>)
|
||||
-2147483649 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
-2147483649 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
-2147483649 checkType { <!TYPE_MISMATCH!>_<!><Int>() }
|
||||
|
||||
checkSubtype<Byte>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>9223372036854775807<!>)
|
||||
checkSubtype<Short>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>9223372036854775807<!>)
|
||||
checkSubtype<Int>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>9223372036854775807<!>)
|
||||
9223372036854775807 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
9223372036854775807 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
9223372036854775807 checkType { <!TYPE_MISMATCH!>_<!><Int>() }
|
||||
|
||||
checkSubtype<Byte>(<!TYPE_MISMATCH!>-9223372036854775807<!>)
|
||||
checkSubtype<Short>(<!TYPE_MISMATCH!>-9223372036854775807<!>)
|
||||
checkSubtype<Int>(<!TYPE_MISMATCH!>-9223372036854775807<!>)
|
||||
-9223372036854775807 checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
-9223372036854775807 checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
-9223372036854775807 checkType { <!TYPE_MISMATCH!>_<!><Int>() }
|
||||
|
||||
checkSubtype<Byte>(<!TYPE_MISMATCH!>-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!><!>)
|
||||
checkSubtype<Short>(<!TYPE_MISMATCH!>-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!><!>)
|
||||
checkSubtype<Int>(-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!>)
|
||||
checkSubtype<Long>(<!TYPE_MISMATCH!>-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!><!>)
|
||||
-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!> checkType { <!TYPE_MISMATCH!>_<!><Byte>() }
|
||||
-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!> checkType { <!TYPE_MISMATCH!>_<!><Short>() }
|
||||
-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!> checkType { _<Int>() }
|
||||
-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!> checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 4
|
||||
DESCRIPTION: Type checking (comparison with invalid types) of too a big integers.
|
||||
*/
|
||||
|
||||
fun case_1() {
|
||||
checkSubtype<Long>(<!TYPE_MISMATCH!>-<!INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!><!>)
|
||||
-<!INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!> checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Long>(<!INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!>)
|
||||
<!INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!> checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Long>(<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000L<!>)
|
||||
<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000L<!> checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Long>(<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000l<!>)
|
||||
<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000l<!> checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Long>(<!TYPE_MISMATCH!>-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000L<!><!>)
|
||||
-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000L<!> checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
|
||||
checkSubtype<Long>(<!TYPE_MISMATCH!>-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000l<!><!>)
|
||||
-<!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000l<!> checkType { <!TYPE_MISMATCH!>_<!><Long>() }
|
||||
}
|
||||
+64
@@ -0,0 +1,64 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 5
|
||||
DESCRIPTION: Check of integer type selection depends on the context (incopatible types).
|
||||
*/
|
||||
|
||||
// FILE: functions.kt
|
||||
|
||||
package functions
|
||||
|
||||
fun f1(x1: Byte) = x1
|
||||
|
||||
fun f2(x1: Short) = x1
|
||||
|
||||
fun f3(x1: Int) = x1
|
||||
|
||||
fun f4(x1: Long) = x1
|
||||
|
||||
// FILE: usages.kt
|
||||
|
||||
import functions.*
|
||||
|
||||
fun case_1() {
|
||||
f1(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>128<!>)
|
||||
f1(<!TYPE_MISMATCH!>-129<!>)
|
||||
f1(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>32767<!>)
|
||||
f1(<!TYPE_MISMATCH!>-32768<!>)
|
||||
f1(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>2147483647<!>)
|
||||
f1(<!TYPE_MISMATCH!>-2147483648<!>)
|
||||
f1(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>9223372036854775807<!>)
|
||||
f1(<!TYPE_MISMATCH!>-9223372036854775807<!>)
|
||||
f1(<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
|
||||
f1(<!TYPE_MISMATCH!>-<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!><!>)
|
||||
}
|
||||
|
||||
fun case_2() {
|
||||
f2(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>32768<!>)
|
||||
f2(<!TYPE_MISMATCH!>-32769<!>)
|
||||
f2(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>2147483647<!>)
|
||||
f2(<!TYPE_MISMATCH!>-2147483648<!>)
|
||||
f2(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>9223372036854775807<!>)
|
||||
f2(<!TYPE_MISMATCH!>-9223372036854775807<!>)
|
||||
f2(<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
|
||||
f2(<!TYPE_MISMATCH!>-<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!><!>)
|
||||
}
|
||||
|
||||
fun case_3() {
|
||||
f3(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>9223372036854775807<!>)
|
||||
f3(<!TYPE_MISMATCH!>-9223372036854775807<!>)
|
||||
f3(<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
|
||||
f3(-<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
|
||||
}
|
||||
|
||||
fun case_4() {
|
||||
f3(<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
|
||||
f3(-<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Type checking of various integer literals with long literal mark.
|
||||
*/
|
||||
|
||||
fun case_1() {
|
||||
0L checkType { _<Long>() }
|
||||
10000000000000L checkType { _<Long>() }
|
||||
0X000Af10cDL checkType { _<Long>() }
|
||||
0x0_0L checkType { _<Long>() }
|
||||
0b100_000_111_111L checkType { _<Long>() }
|
||||
0b0L checkType { _<Long>() }
|
||||
}
|
||||
|
||||
fun case_2() {
|
||||
9223372036854775807L checkType { _<Long>() }
|
||||
-9223372036854775807L checkType { _<Long>() }
|
||||
|
||||
0X7FFFFFFFFFFFFFFFL checkType { _<Long>() }
|
||||
-0x7FFFFFFFFFFFFFFFL checkType { _<Long>() }
|
||||
|
||||
0b111111111111111111111111111111111111111111111111111111111111111L checkType { _<Long>() }
|
||||
-0B111111111111111111111111111111111111111111111111111111111111111L checkType { _<Long>() }
|
||||
}
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Type checking of decimal integer literals.
|
||||
*/
|
||||
|
||||
fun case_1() {
|
||||
0 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0)
|
||||
checkSubtype<Short>(0)
|
||||
checkSubtype<Byte>(0)
|
||||
checkSubtype<Long>(0)
|
||||
|
||||
127 checkType { _<Int>() }
|
||||
checkSubtype<Int>(127)
|
||||
checkSubtype<Short>(127)
|
||||
checkSubtype<Byte>(127)
|
||||
checkSubtype<Long>(127)
|
||||
|
||||
128 checkType { _<Int>() }
|
||||
checkSubtype<Int>(128)
|
||||
checkSubtype<Short>(128)
|
||||
checkSubtype<Long>(128)
|
||||
|
||||
-128 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-128)
|
||||
checkSubtype<Short>(-128)
|
||||
checkSubtype<Byte>(-128)
|
||||
checkSubtype<Long>(-128)
|
||||
|
||||
-129 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-129)
|
||||
checkSubtype<Short>(-129)
|
||||
checkSubtype<Long>(-129)
|
||||
|
||||
32767 checkType { _<Int>() }
|
||||
checkSubtype<Int>(32767)
|
||||
checkSubtype<Short>(32767)
|
||||
checkSubtype<Long>(32767)
|
||||
|
||||
32768 checkType { _<Int>() }
|
||||
checkSubtype<Int>(32768)
|
||||
checkSubtype<Long>(32768)
|
||||
|
||||
-32768 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-32768)
|
||||
checkSubtype<Short>(-32768)
|
||||
checkSubtype<Long>(-32768)
|
||||
|
||||
-32769 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-32769)
|
||||
checkSubtype<Long>(-32769)
|
||||
|
||||
2147483647 checkType { _<Int>() }
|
||||
checkSubtype<Int>(2147483647)
|
||||
checkSubtype<Long>(2147483647)
|
||||
|
||||
2147483648 checkType { _<Long>() }
|
||||
checkSubtype<Long>(2147483648)
|
||||
|
||||
-2147483648 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-2147483648)
|
||||
checkSubtype<Long>(-2147483648)
|
||||
|
||||
-2147483649 checkType { _<Long>() }
|
||||
checkSubtype<Long>(-2147483649)
|
||||
|
||||
9223372036854775807 checkType { _<Long>() }
|
||||
checkSubtype<Long>(9223372036854775807)
|
||||
|
||||
-9223372036854775807 checkType { _<Long>() }
|
||||
checkSubtype<Long>(-9223372036854775807)
|
||||
}
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Type checking of hexadecimal integer literals.
|
||||
*/
|
||||
|
||||
fun case_1() {
|
||||
0x0 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0x0)
|
||||
checkSubtype<Short>(0x0)
|
||||
checkSubtype<Byte>(0x0)
|
||||
checkSubtype<Long>(0x0)
|
||||
|
||||
0x7F checkType { _<Int>() }
|
||||
checkSubtype<Int>(0x7F)
|
||||
checkSubtype<Short>(0x7F)
|
||||
checkSubtype<Byte>(0x7F)
|
||||
checkSubtype<Long>(0x7F)
|
||||
|
||||
0X80 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0X80)
|
||||
checkSubtype<Short>(0X80)
|
||||
checkSubtype<Long>(0X80)
|
||||
|
||||
-0X80 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0X80)
|
||||
checkSubtype<Short>(-0X80)
|
||||
checkSubtype<Byte>(-0X80)
|
||||
checkSubtype<Long>(-0X80)
|
||||
|
||||
-0x81 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0x81)
|
||||
checkSubtype<Short>(-0x81)
|
||||
checkSubtype<Long>(-0x81)
|
||||
|
||||
0x7FFF checkType { _<Int>() }
|
||||
checkSubtype<Int>(0x7FFF)
|
||||
checkSubtype<Short>(0x7FFF)
|
||||
checkSubtype<Long>(0x7FFF)
|
||||
|
||||
0x8000 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0x8000)
|
||||
checkSubtype<Long>(0x8000)
|
||||
|
||||
-0x8000 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0x8000)
|
||||
checkSubtype<Short>(-0x8000)
|
||||
checkSubtype<Long>(-0x8000)
|
||||
|
||||
-0X8001 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0X8001)
|
||||
checkSubtype<Long>(-0X8001)
|
||||
|
||||
0x7FFFFFFF checkType { _<Int>() }
|
||||
checkSubtype<Int>(0x7FFFFFFF)
|
||||
checkSubtype<Long>(0x7FFFFFFF)
|
||||
|
||||
0x80000000 checkType { _<Long>() }
|
||||
checkSubtype<Long>(0x80000000)
|
||||
|
||||
-0x80000000 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0x80000000)
|
||||
checkSubtype<Long>(-0x80000000)
|
||||
|
||||
-0x80000001 checkType { _<Long>() }
|
||||
checkSubtype<Long>(-0x80000001)
|
||||
|
||||
0X7FFFFFFFFFFFFFFF checkType { _<Long>() }
|
||||
checkSubtype<Long>(0X7FFFFFFFFFFFFFFF)
|
||||
|
||||
-0X7FFFFFFFFFFFFFFF checkType { _<Long>() }
|
||||
checkSubtype<Long>(-0X7FFFFFFFFFFFFFFF)
|
||||
}
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 4
|
||||
DESCRIPTION: Type checking of binary integer literals.
|
||||
*/
|
||||
|
||||
fun case_1() {
|
||||
0b0 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0b0)
|
||||
checkSubtype<Short>(0b0)
|
||||
checkSubtype<Byte>(0b0)
|
||||
checkSubtype<Long>(0b0)
|
||||
|
||||
0B1111111 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0B1111111)
|
||||
checkSubtype<Short>(0B1111111)
|
||||
checkSubtype<Byte>(0B1111111)
|
||||
checkSubtype<Long>(0B1111111)
|
||||
|
||||
0b10000000 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0b10000000)
|
||||
checkSubtype<Short>(0b10000000)
|
||||
checkSubtype<Long>(0b10000000)
|
||||
|
||||
-0B10000000 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0B10000000)
|
||||
checkSubtype<Short>(-0B10000000)
|
||||
checkSubtype<Byte>(-0B10000000)
|
||||
checkSubtype<Long>(-0B10000000)
|
||||
|
||||
-0b10000001 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0b10000001)
|
||||
checkSubtype<Short>(-0b10000001)
|
||||
checkSubtype<Long>(-0b10000001)
|
||||
|
||||
0B111111111111111 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0B111111111111111)
|
||||
checkSubtype<Short>(0B111111111111111)
|
||||
checkSubtype<Long>(0B111111111111111)
|
||||
|
||||
0b1000000000000000 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0b1000000000000000)
|
||||
checkSubtype<Long>(0b1000000000000000)
|
||||
|
||||
-0b1000000000000000 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0b1000000000000000)
|
||||
checkSubtype<Short>(-0b1000000000000000)
|
||||
checkSubtype<Long>(-0b1000000000000000)
|
||||
|
||||
-0B1000000000000001 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0B1000000000000001)
|
||||
checkSubtype<Long>(-0B1000000000000001)
|
||||
|
||||
0b1111111111111111111111111111111 checkType { _<Int>() }
|
||||
checkSubtype<Int>(0b1111111111111111111111111111111)
|
||||
checkSubtype<Long>(0b1111111111111111111111111111111)
|
||||
|
||||
0B10000000000000000000000000000000 checkType { _<Long>() }
|
||||
checkSubtype<Long>(0B10000000000000000000000000000000)
|
||||
|
||||
-0B10000000000000000000000000000000 checkType { _<Int>() }
|
||||
checkSubtype<Int>(-0B10000000000000000000000000000000)
|
||||
checkSubtype<Long>(-0B10000000000000000000000000000000)
|
||||
|
||||
-0b10000000000000000000000000000001 checkType { _<Long>() }
|
||||
checkSubtype<Long>(-0b10000000000000000000000000000001)
|
||||
|
||||
0b111111111111111111111111111111111111111111111111111111111111111 checkType { _<Long>() }
|
||||
checkSubtype<Long>(0b111111111111111111111111111111111111111111111111111111111111111)
|
||||
|
||||
-0B111111111111111111111111111111111111111111111111111111111111111 checkType { _<Long>() }
|
||||
checkSubtype<Long>(-0B111111111111111111111111111111111111111111111111111111111111111)
|
||||
}
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
// !CHECK_TYPE
|
||||
// SKIP_TXT
|
||||
|
||||
/*
|
||||
KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] An integer literal with the long literal mark has type kotlin.Long; an integer literal without it has one of the types kotlin.Int/kotlin.Short/kotlin.Byte (the selected type is dependent on the context), if its value is in range of the corresponding type, or type kotlin.Long otherwise.
|
||||
NUMBER: 5
|
||||
DESCRIPTION: Check of integer type selection depends on the context.
|
||||
*/
|
||||
|
||||
// FILE: functions.kt
|
||||
|
||||
package functions
|
||||
|
||||
fun f1(x1: Byte, x2: Short, x3: Int, x4: Long) = x1 + x2 + x3 + x4
|
||||
|
||||
fun f2(x1: Short, x2: Int, x3: Long) = x1 + x2 + x3
|
||||
|
||||
fun f3(x1: Int, x2: Long) = x1 + x2
|
||||
|
||||
fun f4(x1: Long) = x1
|
||||
|
||||
// FILE: usages.kt
|
||||
|
||||
import functions.*
|
||||
|
||||
fun case_1() {
|
||||
f1(0, 0, 0, 0)
|
||||
f1(127, 127, 127, 127)
|
||||
f1(-128, -128, -128, -128)
|
||||
}
|
||||
|
||||
fun case_2() {
|
||||
f2(128, 128, 128)
|
||||
f2(-129, -129, -129)
|
||||
f2(32767, 32767, 32767)
|
||||
f2(-32768, -32768, -32768)
|
||||
}
|
||||
|
||||
fun case_3() {
|
||||
f3(32768, 32768)
|
||||
f3(-32769, -32769)
|
||||
f3(2147483647, 2147483647)
|
||||
f3(-2147483648, -2147483648)
|
||||
}
|
||||
|
||||
fun case_4() {
|
||||
f4(2147483648)
|
||||
f4(-2147483649)
|
||||
f4(9223372036854775807)
|
||||
f4(-9223372036854775807)
|
||||
}
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of binary digit symbols (0 or 1) prefixed by 0b or 0B is a binary integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Binary integer literals with invalid or double prefixes.
|
||||
*/
|
||||
|
||||
val value = 00b000111001
|
||||
val value = 00l0b10001110
|
||||
val value = 0F0l0b11111111
|
||||
val value = 0F0l0b00000000
|
||||
val value = 000000000000000000000000000000000000000000000000000000b001101
|
||||
val value = 00b01
|
||||
val value = 10B1001
|
||||
val value = 01b0001110
|
||||
val value = 0lB0000000
|
||||
val value = 0Fb0000001000000
|
||||
val value = 0e10fb11010001
|
||||
val value = 0EB1100001
|
||||
val value = 100b
|
||||
|
||||
val value = 0BBB
|
||||
val value = 0bBb
|
||||
val value = 0bB11111
|
||||
val value = 0b0B0
|
||||
val value = 0b000b
|
||||
val value = 0000000000b
|
||||
|
||||
val value = 0A
|
||||
val value = 0z
|
||||
+359
@@ -0,0 +1,359 @@
|
||||
KtFile: 1.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0b000111001')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0l')
|
||||
PsiElement(INTEGER_LITERAL)('0b10001110')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0F')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0l')
|
||||
PsiElement(INTEGER_LITERAL)('0b11111111')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0F')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0l')
|
||||
PsiElement(INTEGER_LITERAL)('0b00000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0b001101')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0b01')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('B1001')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('1')
|
||||
PsiElement(IDENTIFIER)('b0001110')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0l')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('B0000000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0F')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b0000001000000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0e10f')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b11010001')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0E')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('B1100001')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('BB')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('Bb')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('B11111')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('B0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b000')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('A')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('z')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of binary digit symbols (0 or 1) prefixed by 0b or 0B is a binary integer literal.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Binary integer literals with not allowed symbols.
|
||||
*/
|
||||
|
||||
val value = 0b101L001
|
||||
val value = 0bf101L001
|
||||
val value = 0bb1110010110
|
||||
val value = 0Bb11001011
|
||||
val value = 0bB100101
|
||||
val value = 0B00b10
|
||||
val value = 0B00B1
|
||||
val value = 0b10b0
|
||||
val value = 0bBb0100
|
||||
val value = 0BG
|
||||
val value = 0bF1z
|
||||
val value = 0b100M000
|
||||
val value = 0BBBB1000001
|
||||
val value = 0b00000010b
|
||||
val value = 0bABCDEFBB
|
||||
val value = 0Babcdefghijklmnopqrstuvwbyz
|
||||
val value = 0BABCDEFGHIJKLMNOPQRSTUVWBYZ
|
||||
val value = 0Bа
|
||||
val value = 0b10С10
|
||||
val value = 0beeeeеееее
|
||||
val value = 0bbbbbbb
|
||||
val value = 0B0BBBBBB
|
||||
val value = 0B0b0
|
||||
val value = 0bAF
|
||||
+363
@@ -0,0 +1,363 @@
|
||||
KtFile: 1.2.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b101L')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('1')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('f101L001')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b1110010110')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b11001011')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('B100101')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B00')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b10')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B00')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('B1')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b10')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('Bb0100')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('G')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('F1z')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b100')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('M000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('BBB1000001')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b00000010')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('ABCDEFBB')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('abcdefghijklmnopqrstuvwbyz')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('ABCDEFGHIJKLMNOPQRSTUVWBYZ')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('а')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b10')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('С10')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('eeeeеееее')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('bbbbbb')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('BBBBBB')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('AF')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] A sequence of binary digit symbols (0 or 1) prefixed by 0b or 0B is a binary integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Binary integer literals with underscore breaking the prefix (in it).
|
||||
*/
|
||||
|
||||
val value = 0_b1_1_0_1_0_1
|
||||
val value = 0_B_______1_______0_______1_______0
|
||||
val value = 0_0B1_1_1_0_1_0_1_0
|
||||
val value = 0_0B000000000
|
||||
val value = 0_0000000000B
|
||||
val value = 0_0b
|
||||
val value = 0____________0b
|
||||
val value = 0_0_b_0
|
||||
val value = 0_b_0
|
||||
val value = 0_b
|
||||
val value = 0_b_
|
||||
val value = 0_b_0_
|
||||
+184
@@ -0,0 +1,184 @@
|
||||
KtFile: 2.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_b1_1_0_1_0_1')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_B_______1_______0_______1_______0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0B1_1_1_0_1_0_1_0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0B000000000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0000000000B')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0b')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('____________0b')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0_b_0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_b_0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_b')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_b_')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_b_0_')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of binary digit symbols (0 or 1) prefixed by 0b or 0B is a binary integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Binary integer literals with valid digit symbols.
|
||||
*/
|
||||
|
||||
val value = 0b0000111110000
|
||||
val value = 0B010101010101
|
||||
val value = 0b10101010101
|
||||
val value = 0B000000000000
|
||||
val value = 0b0
|
||||
val value = 0B0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
val value = 0b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000
|
||||
val value = 0B111111111111111111111111111111111111111111111111111111111111111
|
||||
val value = 0B1
|
||||
val value = 0b111111111111
|
||||
val value = 0b10
|
||||
val value = 0B01
|
||||
val value = 0B100000000
|
||||
val value = 0b000000001
|
||||
|
||||
val value = 0B10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
+154
@@ -0,0 +1,154 @@
|
||||
KtFile: 1.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b0000111110000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B010101010101')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b10101010101')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B000000000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B111111111111111111111111111111111111111111111111111111111111111')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B1')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b111111111111')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B01')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B100000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b000000001')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of binary digit symbols (0 or 1) prefixed by 0b or 0B is a binary integer literal.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Binary integer literals with invalid [2-9] digit symbols.
|
||||
*/
|
||||
|
||||
val value = 0B000123412
|
||||
val value = 0b000000009
|
||||
val value = 0b200000000
|
||||
val value = 0b1234567890
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
KtFile: 1.2.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B000123412')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b000000009')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b200000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b1234567890')
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of binary digit symbols (0 or 1) prefixed by 0b or 0B is a binary integer literal.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Binary integer literals with prefix only (without digit symbols).
|
||||
*/
|
||||
|
||||
val value = 0b
|
||||
val value = 0B
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
KtFile: 1.3.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B')
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Binary integer literals with underscore symbols in the valid positions.
|
||||
*/
|
||||
|
||||
val value = 0b0_00_01_11_11_00_00
|
||||
val value = 0B0_1_0_1_0_1_0_1_0_1_0_1
|
||||
val value = 0b101_010_10101
|
||||
val value = 0B00000000000________________________0
|
||||
val value = 0b0_0
|
||||
val value = 0B00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
val value = 0B11111111111111111111111111_________1111111111111111111111111111111111111
|
||||
val value = 0b1_______________________________________________________________________________________________________________________________________________________0
|
||||
+84
@@ -0,0 +1,84 @@
|
||||
KtFile: 2.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b0_00_01_11_11_00_00')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B0_1_0_1_0_1_0_1_0_1_0_1')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b101_010_10101')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B00000000000________________________0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b0_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B11111111111111111111111111_________1111111111111111111111111111111111111')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b1_______________________________________________________________________________________________________________________________________________________0')
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Binary integer literals with underscore symbols after binary prefix.
|
||||
*/
|
||||
|
||||
val value = 0b_000111010001111
|
||||
val value = 0b_______011001
|
||||
val value = 0B_0_1_0_1_1_0_0
|
||||
val value = 0b_
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
KtFile: 2.2.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b_000111010001111')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b_______011001')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B_0_1_0_1_1_0_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b_')
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Binary integer literals with underscore symbol after the last digit.
|
||||
*/
|
||||
|
||||
val value = 0b0_1_0_1_0_1_____
|
||||
val value = 0B1_______0_______1_______0_
|
||||
val value = 0B000000000_
|
||||
val value = 0b_
|
||||
val value = 0B______________
|
||||
val value = 0B0_
|
||||
val value = 0b10_
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
KtFile: 2.3.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b0_1_0_1_0_1_____')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B1_______0_______1_______0_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B000000000_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B______________')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B0_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0b10_')
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, binary-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 4
|
||||
DESCRIPTION: Binary integer literals with underscore symbol before the first digit (it's considered as identifiers).
|
||||
*/
|
||||
|
||||
val value = _____0b0_1_0_1_0_0
|
||||
val value = _0B1_______0_______1_______0
|
||||
val value = _0_0B1_0_1_0_1_0_0_1
|
||||
val value = _0B000000000
|
||||
val value = _0000000000b
|
||||
val value = _0_9b
|
||||
val value = ____________0b
|
||||
val value = _0_b_0
|
||||
val value = _b_0
|
||||
val value = _b
|
||||
val value = _b_
|
||||
+114
@@ -0,0 +1,114 @@
|
||||
KtFile: 2.4.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_____0b0_1_0_1_0_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0B1_______0_______1_______0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0_0B1_0_1_0_1_0_0_1')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0B000000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0000000000b')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0_9b')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('____________0b')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0_b_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_b_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_b')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_b_')
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Sequences with not all decimal digit symbols
|
||||
*/
|
||||
|
||||
val value = 1234567890b
|
||||
val value = 3456d78
|
||||
val value = 45z67
|
||||
val value = 5ffff6
|
||||
val value = 6f5
|
||||
val value = 7e6e54
|
||||
val value = 876c54d3
|
||||
val value = 0FF
|
||||
val value = 0A
|
||||
|
||||
val value = 0$
|
||||
val value = 2$100
|
||||
val value = 2val value = 2^10
|
||||
val value = 2\n
|
||||
val value = 2@4
|
||||
val value = 0#1
|
||||
val value = 100!10
|
||||
val value = 100&10
|
||||
val value = 100|10
|
||||
val value = 100)(10
|
||||
val value = 100^10
|
||||
val value = 100<10>
|
||||
val value = 100\10
|
||||
val value = 100,10
|
||||
val value = 100:10
|
||||
val value = 100::10
|
||||
val value = 100'10
|
||||
+378
@@ -0,0 +1,378 @@
|
||||
KtFile: 1.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1234567890')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('b')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('3456')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('d78')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('45')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('z67')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('5f')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('fff6')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('6f')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('5')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('7e6')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('e54')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('876')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('c54d3')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0F')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('F')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('A')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('$')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('2')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('$')
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('2')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('2')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('^')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('2')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('\')
|
||||
PsiElement(IDENTIFIER)('n')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('2')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(AT)('@')
|
||||
PsiElement(INTEGER_LITERAL)('4')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(HASH)('#')
|
||||
PsiElement(INTEGER_LITERAL)('1')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(EXCL)('!')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('&')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('|')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(RPAR)(')')
|
||||
PsiElement(LPAR)('(')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('^')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(LT)('<')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(GT)('>')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('\')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(COMMA)(',')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(COLON)(':')
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
CALLABLE_REFERENCE_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiElement(COLONCOLON)('::')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiErrorElement:Expecting an identifier
|
||||
<empty list>
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(CHARACTER_LITERAL)(''10')
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of decimal digit symbols (0 though 9) is a decimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Sequences with decimal digit symbols.
|
||||
*/
|
||||
|
||||
val value = 1234567890
|
||||
val value = 23456789
|
||||
val value = 345678
|
||||
val value = 4567
|
||||
val value = 56
|
||||
val value = 65
|
||||
val value = 7654
|
||||
val value = 876543
|
||||
val value = 98765432
|
||||
|
||||
val value = 0
|
||||
val value = 1
|
||||
|
||||
val value = 100000
|
||||
val value = 1000001
|
||||
|
||||
val value = 9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
|
||||
+144
@@ -0,0 +1,144 @@
|
||||
KtFile: 1.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1234567890')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('23456789')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('345678')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('4567')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('56')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('65')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('7654')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('876543')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('98765432')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('100000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1000001')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999')
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Integers with underscore symbols in the valid positions.
|
||||
*/
|
||||
|
||||
val value = 1234_5678_90
|
||||
val value = 1_2_3_4_5_6_7_8_9_0
|
||||
val value = 1_2
|
||||
val value = 1_00000000000000000_1
|
||||
val value = 1_____________2
|
||||
val value = 9_____________0000
|
||||
val value = 9____________0_0000
|
||||
val value = 1_______________________________________________________________________________________________________________________________________________________0
|
||||
+84
@@ -0,0 +1,84 @@
|
||||
KtFile: 2.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1234_5678_90')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_2_3_4_5_6_7_8_9_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_2')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_00000000000000000_1')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_____________2')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('9_____________0000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('9____________0_0000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_______________________________________________________________________________________________________________________________________________________0')
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Integers with underscore symbol in the last position.
|
||||
*/
|
||||
|
||||
val value = 1_
|
||||
val value = 1_00000000000000000_
|
||||
val value = 1_____________
|
||||
val value = 9____________0_
|
||||
val value = 1_______________________________________________________________________________________________________________________________________________________
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
KtFile: 2.2.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_00000000000000000_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_____________')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('9____________0_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_______________________________________________________________________________________________________________________________________________________')
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Integers with underscore symbols before the first digit (it's considered as identifiers).
|
||||
*/
|
||||
|
||||
val value = _5678_90
|
||||
val value = _2_3_4_5_6_7_8_9_
|
||||
val value = _____________0000
|
||||
val value = _______________________________________________________________________________________________________________________________________________________0
|
||||
val value = ____________________________________________________
|
||||
val value = _
|
||||
val value = _0_
|
||||
val value = _9_
|
||||
+84
@@ -0,0 +1,84 @@
|
||||
KtFile: 2.3.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_5678_90')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_2_3_4_5_6_7_8_9_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_____________0000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_______________________________________________________________________________________________________________________________________________________0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('____________________________________________________')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_9_')
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 2
|
||||
SENTENCE: [1] Even more so, any decimal literal starting with digit 0 and containing more than 1 digit is not a valid decimal literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Integer literals with 0 in the first position and it contains more than 1 digit.
|
||||
*/
|
||||
|
||||
val value = 00
|
||||
val value = 000000
|
||||
val value = 010000
|
||||
val value = 01000100
|
||||
val value = 099999999
|
||||
+68
@@ -0,0 +1,68 @@
|
||||
KtFile: 1.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('10000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('1000100')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('99999999')
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, decimal-integer-literals
|
||||
PARAGRAPH: 2
|
||||
SENTENCE: [1] Even more so, any decimal literal starting with digit 0 and containing more than 1 digit is not a valid decimal literal.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Integer literals with 0 in the first position and it contains more than 1 digit separated by underscore.
|
||||
*/
|
||||
|
||||
val value = 0_0
|
||||
val value = 000_000
|
||||
val value = 0_10000
|
||||
val value = 0_1000100
|
||||
val value = 0_99999999
|
||||
+78
@@ -0,0 +1,78 @@
|
||||
KtFile: 1.2.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(IDENTIFIER)('_000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_10000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_1000100')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_99999999')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of hexadecimal digit symbols (0 through 9, a through f, A through F) prefixed by 0x or 0X is a hexadecimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Hexadecimal integer literals with invalid or double prefixes.
|
||||
*/
|
||||
|
||||
val value = 00x876543
|
||||
val value = 00l0xf876L543
|
||||
val value = 0F0l0xf876L543
|
||||
val value = 0F0l0xf876L543
|
||||
val value = 000000000000000000000000000000000000000000000000000000xAcccccccccA
|
||||
val value = 00xA45
|
||||
|
||||
val value = 0XXX
|
||||
val value = 0xXx
|
||||
val value = 0xX11111
|
||||
val value = 0x0X0
|
||||
val value = 0x000x
|
||||
val value = 0000000000x
|
||||
|
||||
val value = 90X7654
|
||||
val value = 09x98765432
|
||||
val value = 0lX0000000
|
||||
val value = 0Fx0000001000000
|
||||
val value = 0e10fxEeEeEeEe
|
||||
val value = 0EXAAAAAAAA
|
||||
val value = 200x
|
||||
|
||||
val value = 0A
|
||||
val value = 0z
|
||||
+362
@@ -0,0 +1,362 @@
|
||||
KtFile: 1.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0x876543')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0l')
|
||||
PsiElement(INTEGER_LITERAL)('0xf876L')
|
||||
PsiElement(INTEGER_LITERAL)('543')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0F')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0l')
|
||||
PsiElement(INTEGER_LITERAL)('0xf876L')
|
||||
PsiElement(INTEGER_LITERAL)('543')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0F')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0l')
|
||||
PsiElement(INTEGER_LITERAL)('0xf876L')
|
||||
PsiElement(INTEGER_LITERAL)('543')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0xAcccccccccA')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0xA45')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('XX')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('Xx')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('X11111')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('X0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x000')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('90')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('X7654')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('9')
|
||||
PsiElement(IDENTIFIER)('x98765432')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0l')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('X0000000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0F')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x0000001000000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0e10f')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('xEeEeEeEe')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
FLOAT_CONSTANT
|
||||
PsiElement(FLOAT_CONSTANT)('0E')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('XAAAAAAAA')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('200')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('A')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('z')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of hexadecimal digit symbols (0 through 9, a through f, A through F) prefixed by 0x or 0X is a hexadecimal integer literal.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Hexadecimal integer literals with not allowed symbols.
|
||||
*/
|
||||
|
||||
val value = 0x876L543
|
||||
val value = 0xf876L543
|
||||
val value = 0xx1234567890
|
||||
val value = 0Xx23456789
|
||||
val value = 0xX345678
|
||||
val value = 0X45x67
|
||||
val value = 0X50X6
|
||||
val value = 0x60x5
|
||||
val value = 0xXx7654
|
||||
val value = 0XG
|
||||
val value = 0xF1z
|
||||
val value = 0x100M000
|
||||
val value = 0XXXX1000001
|
||||
val value = 0x00000010x
|
||||
val value = 0xABCDEFXX
|
||||
val value = 0Xabcdefghijklmnopqrstuvwxyz
|
||||
val value = 0XABCDEFGHIJKLMNOPQRSTUVWXYZ
|
||||
val value = 0Xа
|
||||
val value = 0x10С10
|
||||
val value = 0xeeeeеееее
|
||||
val value = 0xxxxxxx
|
||||
val value = 0X0XXXXXX
|
||||
val value = 0X0x0
|
||||
|
||||
val value = 0x$
|
||||
val value = 0x4$0x100
|
||||
val value = 0x1val value = 2x^0x10
|
||||
val value = 0X\n
|
||||
val value = 0x@0x4
|
||||
val value = 0x#0x1
|
||||
val value = 0x!0X10
|
||||
val value = 0X&0X10
|
||||
val value = 0X|0X10
|
||||
val value = 0X)(0X10
|
||||
val value = 0x^0x10
|
||||
val value = 0x<0X10>
|
||||
val value = 0x\0X10
|
||||
val value = 0X,0X10
|
||||
val value = 0X:0x10
|
||||
val value = 0X::0x10
|
||||
val value = 0X'0x10
|
||||
+589
@@ -0,0 +1,589 @@
|
||||
KtFile: 1.2.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x876L')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('543')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xf876L')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('543')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x1234567890')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x23456789')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('X345678')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X45')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x67')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X50')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('X6')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x60')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x5')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('Xx7654')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('G')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xF1')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('z')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x100')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('M000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('XXX1000001')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x00000010')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xABCDEF')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('XX')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0Xabcdef')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('ghijklmnopqrstuvwxyz')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0XABCDEF')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('GHIJKLMNOPQRSTUVWXYZ')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('а')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x10')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('С10')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xeeee')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('еееее')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('xxxxxx')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('XXXXXX')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('$')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x4')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('$')
|
||||
PsiElement(INTEGER_LITERAL)('0x100')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x1')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('2')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('x')
|
||||
PsiErrorElement:Expecting an element
|
||||
PsiElement(BAD_CHARACTER)('^')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0x10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('\')
|
||||
PsiElement(IDENTIFIER)('n')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(AT)('@')
|
||||
PsiElement(INTEGER_LITERAL)('0x4')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(HASH)('#')
|
||||
PsiElement(INTEGER_LITERAL)('0x1')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(EXCL)('!')
|
||||
PsiElement(INTEGER_LITERAL)('0X10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('&')
|
||||
PsiElement(INTEGER_LITERAL)('0X10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('|')
|
||||
PsiElement(INTEGER_LITERAL)('0X10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(RPAR)(')')
|
||||
PsiElement(LPAR)('(')
|
||||
PsiElement(INTEGER_LITERAL)('0X10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('^')
|
||||
PsiElement(INTEGER_LITERAL)('0x10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(LT)('<')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X10')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(GT)('>')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(BAD_CHARACTER)('\')
|
||||
PsiElement(INTEGER_LITERAL)('0X10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(COMMA)(',')
|
||||
PsiElement(INTEGER_LITERAL)('0X10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(COLON)(':')
|
||||
PsiElement(INTEGER_LITERAL)('0x10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
CALLABLE_REFERENCE_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
PsiElement(COLONCOLON)('::')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiErrorElement:Expecting an identifier
|
||||
<empty list>
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(INTEGER_LITERAL)('0x10')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
PsiErrorElement:Property getter or setter expected
|
||||
PsiElement(CHARACTER_LITERAL)(''0x10')
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Hexadecimal integer literals with underscore breaking the prefix (in it).
|
||||
*/
|
||||
|
||||
val value = 0_x3_4_5_6_7_8
|
||||
val value = 0_X_______4_______5_______6_______7
|
||||
val value = 0_0X4_3_4_5_6_7_8_9
|
||||
val value = 0_0X000000000
|
||||
val value = 0_0000000000X
|
||||
val value = 0_9x
|
||||
val value = 0____________0x
|
||||
val value = 0_0_x_0
|
||||
val value = 0_x_0
|
||||
val value = 0_x
|
||||
val value = 0_x_
|
||||
val value = 0_x_0_
|
||||
+184
@@ -0,0 +1,184 @@
|
||||
KtFile: 2.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_x3_4_5_6_7_8')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_X_______4_______5_______6_______7')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0X4_3_4_5_6_7_8_9')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0X000000000')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0000000000X')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_9x')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('____________0x')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_0_x_0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_x_0')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_x')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_x_')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('_x_0_')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
+57
@@ -0,0 +1,57 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of hexadecimal digit symbols (0 through 9, a through f, A through F) prefixed by 0x or 0X is a hexadecimal integer literal.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Hexadecimal integer literals with valid symbols.
|
||||
*/
|
||||
|
||||
val value = 0x1234567890
|
||||
val value = 0X23456789
|
||||
val value = 0x345678
|
||||
val value = 0X4567
|
||||
val value = 0X56
|
||||
val value = 0x65
|
||||
val value = 0X7654
|
||||
val value = 0x876543
|
||||
val value = 0x98765432
|
||||
|
||||
val value = 0X0
|
||||
val value = 0x1
|
||||
|
||||
val value = 0x100000
|
||||
val value = 0X1000001
|
||||
|
||||
val value = 0X0000000
|
||||
val value = 0x0000001000000
|
||||
val value = 0x00000010
|
||||
|
||||
val value = 0xABCDEF
|
||||
val value = 0Xabcdef
|
||||
val value = 0xAbcD
|
||||
val value = 0Xa
|
||||
val value = 0xE
|
||||
val value = 0xEeEeEeEe
|
||||
val value = 0XAAAAAAAA
|
||||
val value = 0xcDf
|
||||
val value = 0xAcccccccccA
|
||||
|
||||
val value = 0x0123456789ABCDEF
|
||||
val value = 0x0123456789abcdef
|
||||
val value = 0XAA00AA
|
||||
val value = 0xBc12eF
|
||||
val value = 0xa0
|
||||
val value = 0XE1
|
||||
val value = 0xE1eE2eE3eE4e
|
||||
val value = 0XAAAAAAAA000000000
|
||||
val value = 0xcDf091
|
||||
val value = 0xAcccc0000cccccA
|
||||
val value = 0X0000000A
|
||||
val value = 0xe0000000
|
||||
val value = 0x0000000D0000000
|
||||
val value = 0xA0A
|
||||
|
||||
val value = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
|
||||
|
||||
+404
@@ -0,0 +1,404 @@
|
||||
KtFile: 1.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x1234567890')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X23456789')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x345678')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X4567')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X56')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x65')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X7654')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x876543')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x98765432')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x1')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x100000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X1000001')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X0000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x0000001000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x00000010')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xABCDEF')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0Xabcdef')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xAbcD')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0Xa')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xE')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xEeEeEeEe')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0XAAAAAAAA')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xcDf')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xAcccccccccA')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x0123456789ABCDEF')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x0123456789abcdef')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0XAA00AA')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xBc12eF')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xa0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0XE1')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xE1eE2eE3eE4e')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0XAAAAAAAA000000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xcDf091')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xAcccc0000cccccA')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X0000000A')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xe0000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x0000000D0000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xA0A')
|
||||
PsiWhiteSpace('\n\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] A sequence of hexadecimal digit symbols (0 through 9, a through f, A through F) prefixed by 0x or 0X is a hexadecimal integer literal.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Hexadecimal integer literals with prefix only (without digit symbols).
|
||||
*/
|
||||
|
||||
val value = 0x
|
||||
val value = 0X
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
KtFile: 1.2.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X')
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Hexadecimal integer literals with underscore symbols in the valid positions.
|
||||
*/
|
||||
|
||||
val value = 0x1_234C67890
|
||||
val value = 0XF_______3456789
|
||||
val value = 0x3_4_5_6_7_8
|
||||
val value = 0X4_______5_______d_______7
|
||||
val value = 0X5__________________________________________________________________________________________________6
|
||||
val value = 0x0_______B
|
||||
val value = 0X0_0
|
||||
val value = 0xB_______________________________________________________________________________________________________________________________________________________0
|
||||
val value = 0x1_00000000000000000_1
|
||||
+94
@@ -0,0 +1,94 @@
|
||||
KtFile: 2.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x1_234C67890')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0XF_______3456789')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x3_4_5_6_7_8')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X4_______5_______d_______7')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X5__________________________________________________________________________________________________6')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x0_______B')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X0_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0xB_______________________________________________________________________________________________________________________________________________________0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x1_00000000000000000_1')
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Hexadecimal integer literals with underscore symbols after hexadecimal prefix.
|
||||
*/
|
||||
|
||||
val value = 0x_a2b45f789e
|
||||
val value = 0X_______2f45c7d9
|
||||
val value = 0X_a_3_4_5_6_7_e_e
|
||||
val value = 0x_
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
KtFile: 2.2.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x_a2b45f789e')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X_______2f45c7d9')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X_a_3_4_5_6_7_e_e')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x_')
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 3
|
||||
DESCRIPTION: Hexadecimal integer literals with underscore symbol after the last digit.
|
||||
*/
|
||||
|
||||
val value = 0x3_c_c_c_7_8_____
|
||||
val value = 0Xc_______5_______6_______F_
|
||||
val value = 0X000000000_
|
||||
val value = 0x_
|
||||
val value = 0X______________
|
||||
val value = 0X0_
|
||||
val value = 0X1e_
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
KtFile: 2.3.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x3_c_c_c_7_8_____')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0Xc_______5_______6_______F_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X000000000_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X______________')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X0_')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0X1e_')
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (POSITIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, hexadecimal-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [2] Digits may be separated by an underscore symbol, but no underscore can be placed before the first digit or after the last one.
|
||||
NUMBER: 4
|
||||
DESCRIPTION: Hexadecimal integer literals with underscore symbol before the first digit (it's considered as identifiers).
|
||||
*/
|
||||
|
||||
val value = _____0x3_4_5_6_7_8
|
||||
val value = _0X4_______5_______6_______7
|
||||
val value = _0_0X4_3_4_5_6_7_8_9
|
||||
val value = _0X000000000
|
||||
val value = _0000000000x
|
||||
val value = _0_9x
|
||||
val value = ____________0x
|
||||
val value = _0_x_0
|
||||
val value = _x_0
|
||||
val value = _x
|
||||
val value = _x_
|
||||
+114
@@ -0,0 +1,114 @@
|
||||
KtFile: 2.4.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_____0x3_4_5_6_7_8')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0X4_______5_______6_______7')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0_0X4_3_4_5_6_7_8_9')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0X000000000')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0000000000x')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0_9x')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('____________0x')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_0_x_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_x_0')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_x')
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
REFERENCE_EXPRESSION
|
||||
PsiElement(IDENTIFIER)('_x_')
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] Any of the decimal, hexadecimal or binary literals may be suffixed by the long literal mark (symbol L).
|
||||
NUMBER: 1
|
||||
DESCRIPTION: Various integer literals with a long literal mark doublicate.
|
||||
*/
|
||||
|
||||
val value = 1234567890lL
|
||||
val value = 1Ll
|
||||
val value = 1_ll
|
||||
val value = 1234_5678_90LLLLLL
|
||||
val value = 0x1llllll
|
||||
val value = 0B0LlLlLl
|
||||
+94
@@ -0,0 +1,94 @@
|
||||
KtFile: 1.1.kt
|
||||
PACKAGE_DIRECTIVE
|
||||
<empty list>
|
||||
IMPORT_LIST
|
||||
<empty list>
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1234567890l')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('L')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1L')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('l')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1_l')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('l')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('1234_5678_90L')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('LLLLL')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0x1l')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('lllll')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
PsiWhiteSpace('\n')
|
||||
PROPERTY
|
||||
PsiElement(val)('val')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(IDENTIFIER)('value')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiElement(EQ)('=')
|
||||
PsiWhiteSpace(' ')
|
||||
BINARY_EXPRESSION
|
||||
INTEGER_CONSTANT
|
||||
PsiElement(INTEGER_LITERAL)('0B0L')
|
||||
OPERATION_REFERENCE
|
||||
PsiElement(IDENTIFIER)('lLlLl')
|
||||
PsiErrorElement:Expecting an element
|
||||
<empty list>
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
/*
|
||||
KOTLIN PSI SPEC TEST (NEGATIVE)
|
||||
|
||||
SECTIONS: constant-literals, integer-literals, long-integer-literals
|
||||
PARAGRAPH: 1
|
||||
SENTENCE: [1] Any of the decimal, hexadecimal or binary literals may be suffixed by the long literal mark (symbol L).
|
||||
NUMBER: 2
|
||||
DESCRIPTION: Various integer literals with a long literal mark in not allowed positions.
|
||||
*/
|
||||
|
||||
val value = 0x0123456L789abcdef
|
||||
val value = 0lXal
|
||||
val value = 0xL0L
|
||||
val value = 0X4_______5_______d_______L7l
|
||||
val value = 0xl_l
|
||||
val value = 0b10101010101L0
|
||||
val value = 0bL000000009l
|
||||
val value = 0LB1___L____0____l___1____L___0
|
||||
val value = 0Bl1______________0
|
||||
val value = 0L0L
|
||||
val value = 1L0L
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user