[FIR] Fix TEST SPEC tests

Ensure the test data contents for both the frontends are identical. This is needed for proper analysis of K2-differences.
2023-06-12 15:20:46 +03:00
parent e6633d3d92
commit 7541732752
583 changed files with 4053 additions and 5418 deletions
@@ -1,6 +1,18 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, additive-expression -> paragraph 4 -> sentence 1
+ * PRIMARY LINKS: expressions, additive-expression -> paragraph 4 -> sentence 2
+ * overloadable-operators -> paragraph 4 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: The return type of these functions is not restricted.
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 class Case1(var a: Int) {
    operator fun minus(o: Int): Case1 { TODO() }
@@ -1,11 +1,20 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * MAIN LINK: expressions, built-in-types-and-their-semantics, kotlin.nothing-1 -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check the type of jump expressions is Nothing and code placed on the left side of expression will never be executed
+ */
+
 // TESTCASE NUMBER: 1

 fun case1() {
    var name: Any? = null
-    val men = arrayListOf(Person("Phill"), Person(), Person("Bob"))
+    val men = arrayListOf(Person1("Phill"), Person1(), Person1("Bob"))
    for (k in men) {
        k.name
        loop@ for (i in men) {
@@ -20,13 +29,13 @@ fun case1() {
    val a = 1
 }

-class Person(var name: String? = null) {}
+class Person1(var name: String? = null) {}

 // TESTCASE NUMBER: 2

 fun case2() {
    var name: Any? = null
-    val men = arrayListOf(Person("Phill"), Person(), Person("Bob"))
+    val men = arrayListOf(Person2("Phill"), Person2(), Person2("Bob"))
    for (k in men) {
        loop@ for (i in men) {
            i.name
@@ -40,6 +49,8 @@ fun case2() {
    val a = 1
 }

+class Person2(var name: String? = null) {}
+
 // TESTCASE NUMBER: 3

 fun case3() {
@@ -66,4 +66,4 @@ fun case3() {
        if (x == 3) return
    }
    val a = 1
-}
+}
@@ -1,16 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
-// SKIP_TXT
-
-// TESTCASE NUMBER: 1
-class A(val a: Int)  {
-    fun compareTo(other: A): Int = run {
-        this.a - other.a
-    }
-}
-
-fun case1() {
-    val a3 = A(-1)
-    val a4 = A(-3)
-
-    val x = (a3 <!OPERATOR_MODIFIER_REQUIRED!>><!> a4)
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

@@ -1,6 +1,16 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, comparison-expressions -> paragraph 4 -> sentence 1
+ * PRIMARY LINKS: overloadable-operators -> paragraph 4 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: The compareTo operator function must have return type kotlin.Int
+ */
+
 // TESTCASE NUMBER: 1
 class Case1(val a: Int)  {
    var isCompared = false
@@ -2,6 +2,16 @@
 // SKIP_TXT
 // FULL_JDK

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-313
+ * MAIN LINK: expressions, conditional-expression -> paragraph 6 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: The type of the condition expression must be a subtype of kotlin.Boolean
+ * HELPERS: checkType
+ */
+
 // MODULE: libModule
 // FILE: libModule/JavaContainer.java
 package libModule;
@@ -1,11 +0,0 @@
-// TESTCASE NUMBER: 1
-fun case_1() {
-    true checkType { <!NONE_APPLICABLE!>check<!><Boolean?>() }
-    false checkType { <!NONE_APPLICABLE!>check<!><Boolean?>() }
-
-    true checkType { <!NONE_APPLICABLE!>check<!><Any?>() }
-    false checkType { <!NONE_APPLICABLE!>check<!><Any>() }
-
-    true checkType { <!NONE_APPLICABLE!>check<!><Nothing?>() }
-    false checkType { <!NONE_APPLICABLE!>check<!><Nothing>() }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 /*
 * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
 *
@@ -1,6 +1,20 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-435
+ * MAIN LINK: expressions, constant-literals, character-literals -> paragraph 1 -> sentence 1
+ * PRIMARY LINKS: expressions, constant-literals, character-literals -> paragraph 1 -> sentence 2
+ * expressions, constant-literals, character-literals -> paragraph 2 -> sentence 1
+ * expressions, constant-literals, character-literals -> paragraph 2 -> sentence 2
+ * expressions, constant-literals, character-literals -> paragraph 4 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: A character literal defines a constant holding a unicode character value
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 fun case1() {
    val c = <!EMPTY_CHARACTER_LITERAL!>''<!>
@@ -1,6 +1,18 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, constant-literals, character-literals -> paragraph 4 -> sentence 1
+ * PRIMARY LINKS: expressions, constant-literals, character-literals -> paragraph 5 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: to define a character the unicode codepoint escaped symbol \u could be used with followed by exactly four hexadecimal digits.
+ * HELPERS: checkType
+ */
+
+
 // TESTCASE NUMBER: 1

 fun case1() {
@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, integer-literals, binary-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Binary integer literals with an underscore after the prefix.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!ILLEGAL_UNDERSCORE!>0b_1110100000<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, integer-literals, binary-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 3
+ * DESCRIPTION: Binary integer literals with an underscore in the last position.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!ILLEGAL_UNDERSCORE!>0b0_1_1_0_1_1_____<!>

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 /*
 * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
 *
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 /*
 * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
 *
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 /*
 * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
 *
@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, integer-literals, hexadecimal-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Hexadecimal integer literals with an underscore after the prefix.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!ILLEGAL_UNDERSCORE!>0x_1234567890<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, integer-literals, hexadecimal-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 4
+ * DESCRIPTION: Hexadecimal integer literals with an underscore in the last position.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!ILLEGAL_UNDERSCORE!>0x3_4_5_6_7_8_____<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 1 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Real literals with a many digits in a whole-number part and a fraction part (including conforms).
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 1 -> sentence 3
+ * NUMBER: 2
+ * DESCRIPTION: Real literals suffixed by f/F (the float suffix) with a many digits in a whole-number part and a fraction part  (including conforms).
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.000000000000000000000000000000000000000000001f

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-435
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 2 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Real literals with a not allowed exponent mark at the beginning.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!UNRESOLVED_REFERENCE!>E0<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-435
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 2 -> sentence 1
+ * NUMBER: 3
+ * DESCRIPTION: Real literals suffixed by f/F (float suffix) with a not allowed exponent mark at the beginning.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!UNRESOLVED_REFERENCE!>E0f<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-435
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 2 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: Simple real literals with an exponent mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.0e0

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-435
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 2 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Real literals suffixed by f/F (float suffix) with an exponent mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.0e0f

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 3 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: Simple real literals with omitted a whole-number part.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = .0

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 3 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Real literals with omitted a whole-number part and an exponent mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = .0e0

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 3 -> sentence 1
+ * NUMBER: 5
+ * DESCRIPTION: Real literals suffixed by f/F (float suffix) with omitted a whole-number part and an exponent mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = .0e0f

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 3 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Simple real literals with omitted a fraction part, suffixed by f/F (float suffix).
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0F

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 3 -> sentence 2
+ * NUMBER: 2
+ * DESCRIPTION: Real literals with omitted a fraction part and an exponent mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0e0

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 3 -> sentence 2
+ * NUMBER: 3
+ * DESCRIPTION: Real literals with omitted a fraction part and an exponent mark, suffixed by f/F (float suffix).
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0e0f

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Real literals with underscores at the end.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1= <!ILLEGAL_UNDERSCORE!>.0_0e-0___<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Real literals with underscores before an exponent mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!ILLEGAL_UNDERSCORE!>0_E0<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 2
+ * NUMBER: 2
+ * DESCRIPTION: Real literals with underscores after an exponent mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!ILLEGAL_UNDERSCORE!>0e___0<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 2
+ * NUMBER: 3
+ * DESCRIPTION: Real literals with underscores around an exponent mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!ILLEGAL_UNDERSCORE!>.0__e_0<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: Real literals with underscores in a whole-number part and a fraction part.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.0_0

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Real literals suffixed by f/F (float suffix) with underscores in a whole-number part and a fraction part.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.0_0f

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 1
+ * NUMBER: 3
+ * DESCRIPTION: Real literals suffixed by f/F (float suffix) with an exponent mark and underscores in a whole-number part, a fraction part and an exponent part.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.0_0e1_0f

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 1
+ * NUMBER: 4
+ * DESCRIPTION: Real literals with an omitted whole-number part and underscores in a whole-number part, a fraction part and an exponent part.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = .0_0

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 4 -> sentence 1
+ * NUMBER: 5
+ * DESCRIPTION: Real literals with an omitted fraction part and underscores in a whole-number part, a fraction part and an exponent part.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0_0F

@@ -1,3 +1,13 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 5 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: A type checking of a simple real literal (with/without underscores).
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.1 checkType { check<Double>() }

@@ -1,3 +1,13 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 5 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: A type checking of a real literal with an exponent mark.
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0.0e0 checkType { check<Double>() }

@@ -1,3 +1,13 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 5 -> sentence 1
+ * NUMBER: 3
+ * DESCRIPTION: A type checking of a real literal with omitted a whole-number part.
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = .0 checkType { check<Double>() }

@@ -1,3 +1,13 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 5 -> sentence 1
+ * NUMBER: 4
+ * DESCRIPTION: A type checking of a real literal with omitted a whole-number part and an exponent mark.
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = .0e0 checkType { check<Double>() }

@@ -1,3 +1,13 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, real-literals -> paragraph 5 -> sentence 1
+ * NUMBER: 5
+ * DESCRIPTION: A type checking of a real literal with omitted a fraction part and an exponent mark.
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = 0e0 checkType { check<Double>() }

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, the-types-for-integer-literals -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: Binary and hexadecimal integer literals with a long literal mark only.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!INT_LITERAL_OUT_OF_RANGE!>0bl<!>

@@ -1,3 +1,12 @@
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, the-types-for-integer-literals -> paragraph 1 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Various integer literals with a not allowed underscore before the long literal mark.
+ */
+
 // TESTCASE NUMBER: 1
 val value_1 = <!ILLEGAL_UNDERSCORE!>0b0_l<!>

@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, the-types-for-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Various integer literals with not allowed long literal mark in lower case (type checking).
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1() {
    0<!WRONG_LONG_SUFFIX!>l<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { check<Long>() }
@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, the-types-for-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 2
+ * DESCRIPTION: Type checking (comparison with invalid types) of various integer literals with long literal mark.
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1() {
    0L checkType { <!NONE_APPLICABLE!>check<!><Short>() }
@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, the-types-for-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 3
+ * DESCRIPTION: Type checking (comparison with invalid types) of various integer literals.
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1() {
    0 checkType { <!NONE_APPLICABLE!>check<!><Byte>() }
@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, the-types-for-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 4
+ * DESCRIPTION: Type checking (comparison with invalid types) of too a big integers.
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1() {
    checkSubtype<Long>(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!>)
@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, constant-literals, the-types-for-integer-literals -> paragraph 1 -> sentence 2
+ * NUMBER: 5
+ * DESCRIPTION: Check of integer type selection depends on the context (incopatible types).
+ * HELPERS: checkType
+ */
+
 // FILE: testFunctions.kt

 package functions
@@ -1,82 +0,0 @@
-// SKIP_TXT
-
-// TESTCASE NUMBER: 1
-fun case_1() {
-    0 checkType { check<Int>() }
-    checkSubtype<Int>(0)
-    checkSubtype<Short>(0)
-    checkSubtype<Byte>(0)
-    checkSubtype<Long>(0)
-}
-
-// TESTCASE NUMBER: 2
-fun case_2() {
-    127 checkType { check<Int>() }
-    checkSubtype<Int>(127)
-    checkSubtype<Short>(127)
-    checkSubtype<Byte>(127)
-    checkSubtype<Long>(127)
-
-    128 checkType { check<Int>() }
-    checkSubtype<Int>(128)
-    checkSubtype<Short>(128)
-    checkSubtype<Long>(128)
-
-    -128 checkType { check<Int>() }
-    checkSubtype<Int>(-128)
-    checkSubtype<Short>(-128)
-    checkSubtype<Byte>(-128)
-    checkSubtype<Long>(-128)
-
-    -129 checkType { check<Int>() }
-    checkSubtype<Int>(-129)
-    checkSubtype<Short>(-129)
-    checkSubtype<Long>(-129)
-}
-
-// TESTCASE NUMBER: 3
-fun case_3() {
-    32767 checkType { check<Int>() }
-    checkSubtype<Int>(32767)
-    checkSubtype<Short>(32767)
-    checkSubtype<Long>(32767)
-
-    32768 checkType { check<Int>() }
-    checkSubtype<Int>(32768)
-    checkSubtype<Long>(32768)
-
-    -32768 checkType { check<Int>() }
-    checkSubtype<Int>(-32768)
-    checkSubtype<Short>(-32768)
-    checkSubtype<Long>(-32768)
-
-    -32769 checkType { check<Int>() }
-    checkSubtype<Int>(-32769)
-    checkSubtype<Long>(-32769)
-}
-
-// TESTCASE NUMBER: 4
-fun case_4() {
-    2147483647 checkType { check<Int>() }
-    checkSubtype<Int>(2147483647)
-    checkSubtype<Long>(2147483647)
-
-    2147483648 checkType { check<Long>() }
-    checkSubtype<Long>(2147483648)
-
-    -2147483648 checkType { check<Int>() }
-    checkSubtype<Int>(-2147483648)
-    checkSubtype<Long>(-2147483648)
-
-    -2147483649 checkType { check<Long>() }
-    checkSubtype<Long>(-2147483649)
-}
-
-// TESTCASE NUMBER: 5
-fun case_5() {
-    9223372036854775807 checkType { check<Long>() }
-    checkSubtype<Long>(9223372036854775807)
-
-    -9223372036854775807 checkType { check<Long>() }
-    checkSubtype<Long>(-9223372036854775807)
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT

 /*
@@ -1,82 +0,0 @@
-// SKIP_TXT
-
-// TESTCASE NUMBER: 1
-fun case_1() {
-    0x0 checkType { check<Int>() }
-    checkSubtype<Int>(0x0)
-    checkSubtype<Short>(0x0)
-    checkSubtype<Byte>(0x0)
-    checkSubtype<Long>(0x0)
-}
-
-// TESTCASE NUMBER: 2
-fun case_2() {
-    0x7F checkType { check<Int>() }
-    checkSubtype<Int>(0x7F)
-    checkSubtype<Short>(0x7F)
-    checkSubtype<Byte>(0x7F)
-    checkSubtype<Long>(0x7F)
-
-    0X80 checkType { check<Int>() }
-    checkSubtype<Int>(0X80)
-    checkSubtype<Short>(0X80)
-    checkSubtype<Long>(0X80)
-
-    -0X80 checkType { check<Int>() }
-    checkSubtype<Int>(-0X80)
-    checkSubtype<Short>(-0X80)
-    checkSubtype<Byte>(-0X80)
-    checkSubtype<Long>(-0X80)
-
-    -0x81 checkType { check<Int>() }
-    checkSubtype<Int>(-0x81)
-    checkSubtype<Short>(-0x81)
-    checkSubtype<Long>(-0x81)
-}
-
-// TESTCASE NUMBER: 3
-fun case_3() {
-    0x7FFF checkType { check<Int>() }
-    checkSubtype<Int>(0x7FFF)
-    checkSubtype<Short>(0x7FFF)
-    checkSubtype<Long>(0x7FFF)
-
-    0x8000 checkType { check<Int>() }
-    checkSubtype<Int>(0x8000)
-    checkSubtype<Long>(0x8000)
-
-    -0x8000 checkType { check<Int>() }
-    checkSubtype<Int>(-0x8000)
-    checkSubtype<Short>(-0x8000)
-    checkSubtype<Long>(-0x8000)
-
-    -0X8001 checkType { check<Int>() }
-    checkSubtype<Int>(-0X8001)
-    checkSubtype<Long>(-0X8001)
-}
-
-// TESTCASE NUMBER: 4
-fun case_4() {
-    0x7FFFFFFF checkType { check<Int>() }
-    checkSubtype<Int>(0x7FFFFFFF)
-    checkSubtype<Long>(0x7FFFFFFF)
-
-    0x80000000 checkType { check<Long>() }
-    checkSubtype<Long>(0x80000000)
-
-    -0x80000000 checkType { check<Int>() }
-    checkSubtype<Int>(-0x80000000)
-    checkSubtype<Long>(-0x80000000)
-
-    -0x80000001 checkType { check<Long>() }
-    checkSubtype<Long>(-0x80000001)
-}
-
-// TESTCASE NUMBER: 5
-fun case_5() {
-    0X7FFFFFFFFFFFFFFF checkType { check<Long>() }
-    checkSubtype<Long>(0X7FFFFFFFFFFFFFFF)
-
-    -0X7FFFFFFFFFFFFFFF checkType { check<Long>() }
-    checkSubtype<Long>(-0X7FFFFFFFFFFFFFFF)
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT

 /*
@@ -1,82 +0,0 @@
-// SKIP_TXT
-
-// TESTCASE NUMBER: 1
-fun case_1() {
-    0b0 checkType { check<Int>() }
-    checkSubtype<Int>(0b0)
-    checkSubtype<Short>(0b0)
-    checkSubtype<Byte>(0b0)
-    checkSubtype<Long>(0b0)
-}
-
-// TESTCASE NUMBER: 2
-fun case_2() {
-    0B1111111 checkType { check<Int>() }
-    checkSubtype<Int>(0B1111111)
-    checkSubtype<Short>(0B1111111)
-    checkSubtype<Byte>(0B1111111)
-    checkSubtype<Long>(0B1111111)
-
-    0b10000000 checkType { check<Int>() }
-    checkSubtype<Int>(0b10000000)
-    checkSubtype<Short>(0b10000000)
-    checkSubtype<Long>(0b10000000)
-
-    -0B10000000 checkType { check<Int>() }
-    checkSubtype<Int>(-0B10000000)
-    checkSubtype<Short>(-0B10000000)
-    checkSubtype<Byte>(-0B10000000)
-    checkSubtype<Long>(-0B10000000)
-
-    -0b10000001 checkType { check<Int>() }
-    checkSubtype<Int>(-0b10000001)
-    checkSubtype<Short>(-0b10000001)
-    checkSubtype<Long>(-0b10000001)
-}
-
-// TESTCASE NUMBER: 3
-fun case_3() {
-    0B111111111111111 checkType { check<Int>() }
-    checkSubtype<Int>(0B111111111111111)
-    checkSubtype<Short>(0B111111111111111)
-    checkSubtype<Long>(0B111111111111111)
-
-    0b1000000000000000 checkType { check<Int>() }
-    checkSubtype<Int>(0b1000000000000000)
-    checkSubtype<Long>(0b1000000000000000)
-
-    -0b1000000000000000 checkType { check<Int>() }
-    checkSubtype<Int>(-0b1000000000000000)
-    checkSubtype<Short>(-0b1000000000000000)
-    checkSubtype<Long>(-0b1000000000000000)
-
-    -0B1000000000000001 checkType { check<Int>() }
-    checkSubtype<Int>(-0B1000000000000001)
-    checkSubtype<Long>(-0B1000000000000001)
-}
-
-// TESTCASE NUMBER: 4
-fun case_4() {
-    0b1111111111111111111111111111111 checkType { check<Int>() }
-    checkSubtype<Int>(0b1111111111111111111111111111111)
-    checkSubtype<Long>(0b1111111111111111111111111111111)
-
-    0B10000000000000000000000000000000 checkType { check<Long>() }
-    checkSubtype<Long>(0B10000000000000000000000000000000)
-
-    -0B10000000000000000000000000000000 checkType { check<Int>() }
-    checkSubtype<Int>(-0B10000000000000000000000000000000)
-    checkSubtype<Long>(-0B10000000000000000000000000000000)
-
-    -0b10000000000000000000000000000001 checkType { check<Long>() }
-    checkSubtype<Long>(-0b10000000000000000000000000000001)
-}
-
-// TESTCASE NUMBER: 5
-fun case_5() {
-    0b111111111111111111111111111111111111111111111111111111111111111 checkType { check<Long>() }
-    checkSubtype<Long>(0b111111111111111111111111111111111111111111111111111111111111111)
-
-    -0B111111111111111111111111111111111111111111111111111111111111111 checkType { check<Long>() }
-    checkSubtype<Long>(-0B111111111111111111111111111111111111111111111111111111111111111)
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT

 /*
@@ -1,6 +1,17 @@
 // !DIAGNOSTICS: -UNREACHABLE_CODE -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, elvis-operator-expression -> paragraph 3 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: The type of elvis operator expression is the least upper bound of the non-nullable variant of the type of the left-hand side expression and the type of the right-hand side expression.
+ * HELPERS: checkType
+ */
+
+
 // TESTCASE NUMBER: 1
 fun case1() {
    val x = null ?: getNull()
@@ -1,6 +1,16 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-222
+ * MAIN LINK: expressions, jump-expressions, break-expression -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: A break expression is a jump expression allowed only within loop bodies.
+ */
+
+
 // TESTCASE NUMBER: 1
 fun case1() {
    val inputList = listOf(1, 2, 3)
@@ -1,6 +1,16 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-222
+ * MAIN LINK: expressions, jump-expressions, continue-expression -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: A continue expression is a jump expression allowed only within loop bodies.
+ */
+
+
 // TESTCASE NUMBER: 1
 fun case1() {
    val inputList = listOf(1, 2, 3)
@@ -1,6 +1,16 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-222
+ * MAIN LINK: expressions, jump-expressions, return-expressions -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION:
+ * HELPERS: checkType
+ */
+
 // TESTCASE NUMBER: 1
 fun case1() {
    val x = fooCase1()
@@ -1,6 +1,15 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-313
+ * MAIN LINK: expressions, jump-expressions, return-expressions -> paragraph 4 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: check returning is not allowed from run{...}
+ */
+
 // TESTCASE NUMBER: 1
 // UNEXPECTED BEHAVIOUR
 // ISSUES : KT-35545
@@ -1,6 +1,17 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-313
+ * MAIN LINK: expressions, logical-conjunction-expression -> paragraph 2 -> sentence 1
+ * PRIMARY LINKS: expressions, logical-conjunction-expression -> paragraph 2 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Both operands of a logical conjunction expression must have a type which is a subtype of kotlin.Boolean
+ * HELPERS: checkType
+ */
+
 // MODULE: libModule
 // FILE: libModule/JavaClass.java
 package libModule;
@@ -1,6 +1,17 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-313
+ * MAIN LINK: expressions, logical-conjunction-expression -> paragraph 2 -> sentence 1
+ * PRIMARY LINKS: expressions, logical-conjunction-expression -> paragraph 2 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Both operands of a logical conjunction expression must have a type which is a subtype of kotlin.Boolean
+ * HELPERS: checkType
+ */
+
 // MODULE: libModule
 // FILE: libModule/JavaClass.java
 package libModule;
@@ -1,6 +1,17 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-313
+ * MAIN LINK: expressions, logical-disjunction-expression -> paragraph 2 -> sentence 1
+ * PRIMARY LINKS: expressions, logical-disjunction-expression -> paragraph 2 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: Both operands of a logical disjunction expression must have a type which is a subtype of kotlin.Boolean, otherwise it is a type error.
+ * HELPERS: checkType
+ */
+
 // MODULE: libModule
 // FILE: libModule/JavaClass.java
 package libModule;
@@ -1,6 +1,17 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-313
+ * MAIN LINK: expressions, logical-disjunction-expression -> paragraph 2 -> sentence 1
+ * PRIMARY LINKS: expressions, logical-disjunction-expression -> paragraph 2 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION:Both operands of a logical disjunction expression must have a type which is a subtype of kotlin.Boolean
+ * HELPERS: checkType
+ */
+
 // MODULE: libModule
 // FILE: libModule/JavaClass.java
 package libModule;
@@ -1,6 +1,16 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, multiplicative-expression -> paragraph 5 -> sentence 1
+ * PRIMARY LINKS: expressions, multiplicative-expression -> paragraph 5 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: The return type of these functions is not restricted.
+ * HELPERS: checkType
+ */
 // TESTCASE NUMBER: 1
 class Case1(var a: Int) {
    operator fun times(o: Int): Any? { TODO() }
@@ -1,44 +0,0 @@
-// !DIAGNOSTICS: -UNREACHABLE_CODE -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
-// SKIP_TXT
-
-// MODULE: libModule
-// FILE: libModule/JavaClass.java
-package libModule;
-
-public class JavaClass {
-    public static final boolean FALSE = false;
-    public static int obj = 5;
-}
-
-
-// MODULE: mainModule(libModule)
-// FILE: KotlinClass.kt
-package mainModule
-import libModule.*
-
-
-// TESTCASE NUMBER: 1
-fun case1() {
-    val res = JavaClass.FALSE<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
-}
-
-// TESTCASE NUMBER: 2
-fun case2() {
-    val x = JavaClass.obj<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
-}
-
-// TESTCASE NUMBER: 3
-fun case3() {
-    val a = false
-    val x = a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
-}
-
-// TESTCASE NUMBER: 4
-fun case4() {
-    val x = "weds"<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
-}
-
-// TESTCASE NUMBER: 5
-fun case5(nothing: Nothing) {
-    val y = nothing<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNREACHABLE_CODE -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

@@ -1,6 +1,17 @@
 // !DIAGNOSTICS: -UNREACHABLE_CODE -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-296
+ * MAIN LINK: expressions, not-null-assertion-expression -> paragraph 3 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: The type of non-null assertion e!! expression is the non-nullable variant of the type of e.
+ * HELPERS: checkType
+ */
+
+
 // MODULE: libModule
 // FILE: libModule/JavaClass.java
 package libModule;
@@ -1,14 +1,15 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

-class A() {
-    var i = 0
-
-    operator fun dec(): A {
-        this.i--
-        return this
-    }
-}
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * MAIN LINK: expressions, prefix-expressions, prefix-decrement-expression -> paragraph 4 -> sentence 1
+ * PRIMARY LINKS: statements, assignments -> paragraph 3 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: check unsafe prefix decrement expression call for an assignable expression
+ */

 // TESTCASE NUMBER: 1

@@ -22,6 +23,15 @@ class Case1() {
    var a: A = A()
 }

+class A() {
+    var i = 0
+
+    operator fun dec(): A {
+        this.i--
+        return this
+    }
+}
+
 // TESTCASE NUMBER: 2

 fun case2() {
@@ -30,5 +40,14 @@ fun case2() {
 }

 class Case2() {
-    val a = A()
+    val a = A2()
 }
+
+class A2() {
+    var i = 0
+
+    operator fun dec(): A2 {
+        this.i--
+        return this
+    }
+}
@@ -11,7 +11,6 @@
 * DESCRIPTION: check unsafe prefix decrement expression call for an assignable expression
 */

-
 // TESTCASE NUMBER: 1

 fun case1() {
@@ -1,37 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
-// SKIP_TXT
-
-// TESTCASE NUMBER: 1
-
-fun case1() {
-    var a = Case1()
-    val res: Any? = <!RESULT_TYPE_MISMATCH!>++<!>a
-}
-
-
-class Case1() {
-
-    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun inc(): B {
-        TODO()
-    }
-}
-
-class B() {}
-
-// TESTCASE NUMBER: 2
-
-fun case2() {
-    var a = Case2()
-    val res: Any? = <!RESULT_TYPE_MISMATCH!>++<!>a
-}
-
-class Case2() : C() {
-    var i = 0
-
-    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun inc(): C {
-        TODO()
-    }
-
-}
-
-open class C() {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

@@ -1,6 +1,20 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-213
+ * MAIN LINK: expressions, prefix-expressions, prefix-increment-expression -> paragraph 4 -> sentence 1
+ * PRIMARY LINKS: statements, assignments -> paragraph 3 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: check unsafe prefix increment expression call for an assignable expression
+ */
+
+// FILE: TestCase1.kt
+// TESTCASE NUMBER: 1
+package testPackCase1
+
 class A() {
    var i = 0

@@ -10,8 +24,6 @@ class A() {
    }
 }

-// TESTCASE NUMBER: 1
-
 fun case1() {
    var b: Case1? = Case1()
    ++b?.a
@@ -22,7 +34,18 @@ class Case1() {
    var a: A = A()
 }

+// FILE: TestCase2.kt
 // TESTCASE NUMBER: 2
+package testPackCase2
+
+class A() {
+    var i = 0
+
+    operator fun inc(): A {
+        this.i++
+        return this
+    }
+}

 fun case2() {
    var b= Case2()
@@ -11,7 +11,6 @@
 * DESCRIPTION: check unsafe prefix increment expression call for an assignable expression
 */

-
 // FILE: TestCase1.kt
 // TESTCASE NUMBER: 1
 package testPackCase1
@@ -55,4 +54,4 @@ fun case2() {

 class Case2() {
    val a = A()
-}
+}
@@ -1,6 +1,18 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, range-expression -> paragraph 4 -> sentence 1
+ * PRIMARY LINKS: expressions, range-expression -> paragraph 4 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: The return type of range operator is not restricted.
+ * HELPERS: checkType
+ */
+
+
 // TESTCASE NUMBER: 1
 class Case1() {
    operator fun rangeTo(o: Case1): Nothing?{
@@ -1,6 +1,15 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, try-expression -> paragraph 1 -> sentence 3
+ * PRIMARY LINKS: expressions, try-expression -> paragraph 1 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: try-expression has to start with a try body and continue with zero ore more catch blocks
+ */
 fun throwException(): Nothing = throw Exception()

 class ExcA() : Exception()
@@ -1,6 +1,15 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, try-expression -> paragraph 1 -> sentence 4
+ * PRIMARY LINKS: expressions, try-expression -> paragraph 1 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: try-expression has to start with a try body, catch blocks and finally block
+ */
 fun throwException(): Nothing = throw Exception()

 class ExcA() : Exception()
@@ -1,6 +1,16 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK:expressions, try-expression -> paragraph 1 -> sentence 1
+ * PRIMARY LINKS: expressions, try-expression -> paragraph 1 -> sentence 2
+ * expressions, try-expression -> paragraph 1 -> sentence 5
+ * NUMBER: 1
+ * DESCRIPTION: try-expression has to start with a try body
+ */
 fun throwException(): Nothing = throw Exception()


@@ -1,5 +1,16 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, try-expression -> paragraph 2 -> sentence 2
+ * PRIMARY LINKS: expressions, try-expression -> paragraph 2 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: catch block is evaluated immediately after the exception is thrown and the exception itself is passed inside the catch block as the corresponding parameter.
+ */
+
+
 // TESTCASE NUMBER: 1

 fun case1() {
@@ -1,6 +1,16 @@
 // !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, try-expression -> paragraph 5 -> sentence 1
+ * PRIMARY LINKS: expressions, try-expression -> paragraph 4 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: If no exception is thrown during the evaluation of the try body, no catch blocks are executed, the finally block is evaluated after the try body, and the program execution continues as normal.
+ */
+
 // TESTCASE NUMBER: 1

 fun case1(): String {
@@ -1,6 +1,16 @@
 // !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * MAIN LINK: expressions, try-expression -> paragraph 5 -> sentence 2
+ * PRIMARY LINKS: expressions, try-expression -> paragraph 4 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: If an exception was thrown, but no catch block matched its type, the finally block is evaluated before propagating the exception up the call stack.
+ */
+
 /*
 * TESTCASE NUMBER: 1
 * UNEXPECTED BEHAVIOUR
@@ -1,16 +1,31 @@
 // !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_VARIABLE -UNUSED_PARAMETER -FINAL_UPPER_BOUND
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-296
+ * MAIN LINK: expressions, try-expression -> paragraph 8 -> sentence 1
+ * PRIMARY LINKS: expressions, try-expression -> paragraph 9 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: The type of the try-expression is the least upper bound of the types of the last expressions of the try body and the last expressions of all the catch blocks
+ */
+
+// FILE: TestCase1.kt
+// TESTCASE NUMBER: 1
+package testPackCase1
+
 fun throwExceptionA(b: Boolean) = run { if (b) throw ExcA() }

+class ExcA() : Exception()
+class ExcB() : Exception()
+
 open class A<T>(var data: T) {
    fun foo(d: A<T>) {}
 }

 class B<T>(data: T) : A<T>(data)

-// TESTCASE NUMBER: 1
-
 fun case1() {
    val tryVal: B<String> =
    <!TYPE_MISMATCH, TYPE_MISMATCH!>try {
@@ -19,11 +34,24 @@ fun case1() {
    } catch (e: Exception) {
        B("")
    }<!>
-
-
 }

+// FILE: TestCase2.kt
 // TESTCASE NUMBER: 2
+package testPackCase2
+
+fun throwExceptionA(b: Boolean) = run { if (b) throw ExcA() }
+
+class ExcA() : Exception()
+class ExcB() : Exception()
+
+open class A<T>(var data: T) {
+    fun foo(d: A<T>) {}
+}
+
+class B<T>(data: T) : A<T>(data)
+
+

 fun case2() {
    val tryVal: A<String> =
@@ -35,11 +63,20 @@ fun case2() {
    }<!>
 }

-/*
- * TESTCASE NUMBER: 3
- * UNEXPECTED BEHAVIOUR
- * ISSUES: KT-35494
- */
+
+// FILE: TestCase3.kt
+// TESTCASE NUMBER: 3
+// ISSUES: KT-35494
+package testPackCase3
+
+fun throwExceptionA(b: Boolean) = run { if (b) throw ExcA() }
+
+open class A<T>(var data: T) {
+    fun foo(d: A<T>) {}
+}
+
+class B<T>(data: T) : A<T>(data)
+
 fun case3() {
    val tryVal: A<Int> =
    <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>try {
@@ -26,7 +26,6 @@ open class A<T>(var data: T) {

 class B<T>(data: T) : A<T>(data)

-
 fun case1() {
    val tryVal: B<String> =
    try <!TYPE_MISMATCH!>{
@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1
+ * NUMBER: 3
+ * DESCRIPTION: Exhaustive when, with bound value (sealed, enum, boolean), with redundant else branch.
+ * HELPERS: enumClasses, sealedClasses
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1(value_1: EnumClass): String = when (value_1) {
    EnumClass.EAST -> ""
@@ -1,18 +0,0 @@
-// SKIP_TXT
-
-/*
- * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
- *
- * SPEC VERSION: 0.1-435
- * MAIN LINK: expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 11
- * NUMBER: 1
- * DESCRIPTION: Exhaustive when using nullable boolean values.
- */
-
-// TESTCASE NUMBER: 1
-fun case_1(value_1: Boolean?): String = when (value_1) {
-    true -> ""
-    false -> ""
-    null -> ""
-}
-
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT
 // LANGUAGE: -ProhibitSimplificationOfNonTrivialConstBooleanExpressions

@@ -1,5 +1,14 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-435
+ * MAIN LINK: expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 11
+ * NUMBER: 3
+ * DESCRIPTION: Exhaustive when using subclasses of the nullable sealed class.
+ * HELPERS: sealedClasses
+ */

 // TESTCASE NUMBER: 1
 fun case_1(value_1: SealedClass?): Int = when (value_1) {
@@ -1,17 +0,0 @@
-// SKIP_TXT
-
-/*
- * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
- *
- * SPEC VERSION: 0.1-100
- * MAIN LINK: expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 3
- * NUMBER: 1
- * DESCRIPTION: Exhaustive when using boolean values.
- */
-
-// TESTCASE NUMBER: 1
-fun case_1(value_1: Boolean): String = when (value_1) {
-    true -> ""
-    false -> ""
-}
-
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // SKIP_TXT
 // LANGUAGE: -ProhibitSimplificationOfNonTrivialConstBooleanExpressions

@@ -1,6 +1,15 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-435
+ * MAIN LINK: expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 7
+ * NUMBER: 1
+ * DESCRIPTION: Exhaustive when using subclasses of the sealed class.
+ * HELPERS: sealedClasses
+ */

 // TESTCASE NUMBER: 1
 fun case_1(value_1: SealedClass): Int = when (value_1) {
@@ -1,5 +1,14 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, when-expression -> paragraph 1 -> sentence 3
+ * NUMBER: 1
+ * DESCRIPTION: Empty when with bound value.
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1(value_1: Int) {
    when (value_1) {}
@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, when-expression -> paragraph 2 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: When with non-boolean value in the when condition.
+ * HELPERS: typesProvider
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1(value_1: Int, value_2: String, value_3: TypesProvider): String {
    when {
@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, when-expression -> paragraph 2 -> sentence 2
+ * NUMBER: 2
+ * DESCRIPTION: When without bound value, forbidden comma in the when condition.
+ * HELPERS: typesProvider, classes
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1(value_1: TypesProvider) {
    when {
@@ -13,8 +13,8 @@
 // TESTCASE NUMBER: 1
 fun case_1(value_1: TypesProvider) {
    when {
-        getBoolean()<!COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT!>,<!> value_1.getBoolean()  -> return 
-        value_1.getBoolean() && getBoolean()<!COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT!>,<!> getLong() == 1000L -> return 
+        getBoolean()<!COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT!>,<!> value_1.getBoolean()  -> return
+        value_1.getBoolean() && getBoolean()<!COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT!>,<!> getLong() == 1000L -> return
        <!TYPE_MISMATCH!>Out<Int>()<!><!COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT!>,<!> <!TYPE_MISMATCH!>getLong()<!><!COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT!>,<!> <!TYPE_MISMATCH!>{}<!><!COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT!>,<!> <!TYPE_MISMATCH!>Any()<!><!COMMA_IN_WHEN_CONDITION_WITHOUT_ARGUMENT!>,<!> throw Exception() -> return
    }

@@ -1,6 +1,17 @@
+// LANGUAGE: +WarnAboutNonExhaustiveWhenOnAlgebraicTypes
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -DEBUG_INFO_SMARTCAST
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, when-expression -> paragraph 2 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: When without bound value, various expressions in the control structure body.
+ * HELPERS: typesProvider, classes, functions
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1(value_1: Int) {
    when {
@@ -60,11 +71,14 @@ fun case_5(value_1: Int, value_2: Int, value_3: Boolean?) {
            false -> "2"
            null -> "3"
        }
-        value_1 == 5 -> <!NO_ELSE_IN_WHEN!>when<!> (value_3) {
+        value_1 == 5 -> when (value_3) {
            true -> "1"
            false -> "2"
+            else -> ""
+        }
+        value_1 == 6 -> when (value_3) {
+            else -> ""
        }
-        value_1 == 6 -> <!NO_ELSE_IN_WHEN!>when<!> (value_3) {}
    }
 }

@@ -108,7 +122,6 @@ fun case_8(value_1: Int, value_2: Int) = when {

 /*
 * TESTCASE NUMBER: 9
- * UNEXPECTED BEHAVIOUR
 * ISSUES: KT-37249
 */
 fun case_9(value_1: Int, value_2: String, value_3: String) = when {
@@ -1,5 +1,14 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, when-expression -> paragraph 2 -> sentence 1
+ * NUMBER: 2
+ * DESCRIPTION: Allowed break and continue in the control structure body of when.
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1(value_1: Int): String {
    while (true) {
@@ -1,5 +1,15 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, when-expression -> paragraph 2 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: When without bound value, various boolean values in the when condition.
+ * HELPERS: typesProvider, enumClasses, sealedClasses, classes
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1(value_1: Boolean, value_2: Long): Int {
    return when {
@@ -1,5 +1,17 @@
 // SKIP_TXT

+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-100
+ * MAIN LINK: expressions, when-expression -> paragraph 2 -> sentence 2
+ * NUMBER: 3
+ * DESCRIPTION: 'When' without bound value and with Nothing in condition (subtype of Boolean).
+ * DISCUSSION
+ * ISSUES: KT-25948
+ * HELPERS: typesProvider
+ */
+
 // TESTCASE NUMBER: 1
 fun case_1(value_1: TypesProvider) {
    when {
--- a/Show More
+++ b/Show More