diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos/1.1.fir.kt
new file mode 100644
index 00000000000..8a74f34da70
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos/1.1.fir.kt
@@ -0,0 +1,76 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, additive-expression -> paragraph 4 -> sentence 1
+ * RELEVANT PLACES: 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() }
+    operator fun minus(o: Case1):Case1 { TODO() }
+    operator fun plus(o: Int): Case1 { TODO() }
+    operator fun plus(o: Case1): Case1 { TODO() }
+}
+
+fun case1() {
+    val a = Case1(1) + 1
+    val b = Case1(1) + Case1( 1)
+    val c = Case1(1) - 1
+    val d = Case1(1) - Case1( 1)
+
+    a checkType { check<Case1>() }
+    b checkType { check<Case1>() }
+    c checkType { check<Case1>() }
+    d checkType { check<Case1>() }
+}
+
+
+// TESTCASE NUMBER: 2
+class Case2(var a: Int) {
+    operator fun minus(o: Int): Nothing? { TODO() }
+    operator fun minus(o: Case2):Nothing? { TODO() }
+    operator fun plus(o: Int): Nothing? { TODO() }
+    operator fun plus(o: Case2): Nothing? { TODO() }
+}
+
+fun case2() {
+    val a = Case2(1) + 1
+    val b = Case2(1) + Case2( 1)
+    val c = Case2(1) - 1
+    val d = Case2(1) - Case2( 1)
+
+    a checkType { check<Nothing?>() }
+    b checkType { check<Nothing?>() }
+    c checkType { check<Nothing?>() }
+    d checkType { check<Nothing?>() }
+}
+
+// TESTCASE NUMBER: 3
+class Case3(var a: Int) {
+    operator fun minus(o: Int): Any? { TODO() }
+    operator fun minus(o: Case3):Any? { TODO() }
+    operator fun plus(o: Int): Any? { TODO() }
+    operator fun plus(o: Case3): Any? { TODO() }
+}
+
+fun case3() {
+    val a = Case3(1) + 1
+    val b = Case3(1) + Case3( 1)
+    val c = Case3(1) - 1
+    val d = Case3(1) - Case3( 1)
+
+    a checkType { check<Any?>() }
+    b checkType { check<Any?>() }
+    c checkType { check<Any?>() }
+    d checkType { check<Any?>() }
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.1.fir.kt
new file mode 100644
index 00000000000..aa9fdc78400
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos/1.1.fir.kt
@@ -0,0 +1,69 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: 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"))
+    for (k in men) {
+        k.name
+        loop@ for (i in men) {
+            i.name
+            val valeua : Int =     break@loop
+            i.name
+        }
+        k.name
+        val s = k.name ?: break
+        k.name
+    }
+    val a = 1
+}
+
+class Person(var name: String? = null) {}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    var name: Any? = null
+    val men = arrayListOf(Person("Phill"), Person(), Person("Bob"))
+    for (k in men) {
+        loop@ for (i in men) {
+            i.name
+            val val1 =    continue@loop
+            val1
+            i.name
+        }
+        val s = k.name ?: continue
+        k.name
+    }
+    val a = 1
+}
+
+// TESTCASE NUMBER: 3
+
+fun case3() {
+    listOf(1, 2, 3, 4, 5).forEach { x ->
+        val k = x
+
+        listOf(1, 2, 3, 4, 5).forEach lit@{
+            it
+            return@lit
+            print(it)
+        }
+        val y = x
+        if (x == 3) return
+    }
+    val a = 1
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg/2.1.fir.kt
new file mode 100644
index 00000000000..1ec85e565da
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg/2.1.fir.kt
@@ -0,0 +1,27 @@
+// !LANGUAGE: +NewInference
+// !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-220
+ * PLACE: expressions, comparison-expressions -> paragraph 1 -> sentence 2
+ * RELEVANT PLACES: overloadable-operators -> paragraph 4 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: <, >, <= and >=  operators are overloadable
+ */
+
+// 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 > a4)
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg/1.1.fir.kt
new file mode 100644
index 00000000000..dae43a51a65
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg/1.1.fir.kt
@@ -0,0 +1,87 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, comparison-expressions -> paragraph 4 -> sentence 1
+ * RELEVANT PLACES: 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
+    operator fun compareTo(other: Case1):Any = run{
+        TODO()
+    }
+}
+
+fun case1() {
+    val a3 = Case1(-1)
+    val a4 = Case1(-3)
+
+    val x0 = a3 > a4
+    val x1 = a3 < a4
+    val x2 = a3 >= a4
+    val x3 = a3 <= a4
+}
+
+
+// TESTCASE NUMBER: 2
+class Case2(val a: Int) {
+    var isCompared = false
+    operator fun compareTo(other: Case2): Nothing = run {
+        TODO()
+    }
+}
+
+fun case2() {
+    val a3 = Case2(-1)
+    val a4 = Case2(-3)
+
+    val x0 = a3 > a4
+    val x1 = a3 < a4
+    val x2 = a3 >= a4
+    val x3 = a3 <= a4
+}
+
+
+// TESTCASE NUMBER: 3
+class Case3(val a: Int) {
+    var isCompared = false
+    operator fun compareTo(other: Case3):Long = run{
+        TODO()
+    }
+}
+
+fun case3() {
+    val a3 = Case3(-1)
+    val a4 = Case3(-3)
+
+    val x0 = a3 > a4
+    val x1 = a3 < a4
+    val x2 = a3 >= a4
+    val x3 = a3 <= a4
+}
+
+// TESTCASE NUMBER: 4
+class Case4(val a: Int) {
+    var isCompared = false
+    operator fun compareTo(other: Case4):Int? = run{
+        TODO()
+    }
+}
+
+fun case4() {
+    val a3 = Case4(-1)
+    val a4 = Case4(-3)
+
+    val x0 = a3 > a4
+    val x1 = a3 < a4
+    val x2 = a3 >= a4
+    val x3 = a3 <= a4
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg/1.1.fir.kt
new file mode 100644
index 00000000000..5eff5eee8a1
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg/1.1.fir.kt
@@ -0,0 +1,70 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
+// SKIP_TXT
+// FULL_JDK
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
+ *
+ * SPEC VERSION: 0.1-313
+ * PLACE: 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;
+
+public class JavaContainer {
+    public static boolean ab;
+    public static final Boolean aB;
+    public static Object aO = false;
+}
+
+// MODULE: mainModule(libModule)
+// FILE: KotlinClass.kt
+package mainModule
+import libModule.*
+import checkSubtype
+
+/*
+ * TESTCASE NUMBER: 1
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-35517
+ */
+fun case1() {
+    val a: Any = true
+    if (a) { "true" } else "false"
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Boolean>(a)
+}
+
+/*
+ * TESTCASE NUMBER: 2
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-35517
+ */
+fun case2() {
+    val a = JavaContainer.aO
+    if (a) { "true" } else "false"
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Boolean>(a)
+}
+
+// TESTCASE NUMBER: 3
+// FILE: JavaClassCase3.java
+public class JavaClassCase3{
+    public static <T> T id(T x) {
+        return null;
+    }
+}
+
+// FILE: KotlinClassCase3.kt
+// TESTCASE NUMBER: 3
+fun case3() {
+    val x = JavaClassCase3.id(null) // Nothing!
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing?..kotlin.Nothing??")!>x<!>
+    val a = if (x) {
+        "NOK"
+    } else "NOK"
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos/1.1.fir.kt
new file mode 100644
index 00000000000..d783d0d0c92
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos/1.1.fir.kt
@@ -0,0 +1,43 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: 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()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Boolean?")!>x<!>
+}
+
+fun getNull(): Boolean? = null
+
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val x = A(mutableSetOf({ false }, { println("") })).b ?: false
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>x<!>
+}
+
+class A(val b: Set<Any>? = null)
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    val x = null?: throw Exception()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>x<!>
+}
+
+// TESTCASE NUMBER: 4
+fun case4() {
+    val x = null ?: null
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing?")!>x<!>
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg/1.1.fir.kt
new file mode 100644
index 00000000000..31254c991ad
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg/1.1.fir.kt
@@ -0,0 +1,38 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: 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)
+    inputList.forEach {
+        listOf("1.", "2.", "3.").forEach {
+            if (true) <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break@forEach<!>
+        }
+    }
+}
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val inputList = listOf(1, 2, 3)
+    inputList.forEach {
+        listOf("1.", "2.", "3.").forEach {
+            if (true) <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break<!>
+        }
+    }
+}
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break<!>
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg/1.1.fir.kt
new file mode 100644
index 00000000000..d5e5857766f
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg/1.1.fir.kt
@@ -0,0 +1,38 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: 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)
+    inputList.forEach {
+        listOf("1.", "2.", "3.").forEach {
+            if (true) <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue@forEach<!>
+        }
+    }
+}
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val inputList = listOf(1, 2, 3)
+    inputList.forEach {
+        listOf("1.", "2.", "3.").forEach {
+            if (true) <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue<!>
+        }
+    }
+}
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue<!>
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos/1.1.fir.kt
new file mode 100644
index 00000000000..aa9b92de8a0
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos/1.1.fir.kt
@@ -0,0 +1,63 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, jump-expressions, return-expressions -> paragraph 1 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION:
+ * HELPERS: checkType
+ */
+
+// TESTCASE NUMBER: 1
+fun case1() {
+    val x = fooCase1()
+    x checkType { check<Case1>() }
+}
+
+class Case1
+
+fun fooCase1(): Case1 = TODO()
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val x = fooCase2()
+    x checkType { check<Case1>() }
+}
+
+fun fooCase2(): Case1 {
+    val x = ""
+    return Case1()
+    val y = ""
+}
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    val x = object : Case13 {
+        override fun fooCase3(): Int {
+            return 1
+            "str"
+            3
+        }
+    }.fooCase3()
+
+    x checkType { check<Int>() }
+
+}
+
+interface Case13 {
+    fun fooCase3(): Int
+}
+
+// TESTCASE NUMBER: 4
+fun case4() {
+    val x = fooCase4()
+    x checkType { check<kotlin.Unit>() }
+}
+
+fun fooCase4()  {
+    return
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg/1.1.fir.kt
new file mode 100644
index 00000000000..ac2a74da8ef
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg/1.1.fir.kt
@@ -0,0 +1,21 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: 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
+fun case1(a: Boolean) = run { println("d"); return true }
+
+// TESTCASE NUMBER: 2
+val case2
+get() = run { println("d"); return true }
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg/1.1.fir.kt
new file mode 100644
index 00000000000..92c00300789
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg/1.1.fir.kt
@@ -0,0 +1,81 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, logical-conjunction-expression -> paragraph 2 -> sentence 1
+ * RELEVANT PLACES: 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;
+
+public class JavaClass {
+    public static Object VALUE = false;
+}
+
+// MODULE: mainModule(libModule)
+// FILE: KotlinClass.kt
+package mainModule
+import libModule.*
+import checkSubtype
+import checkType
+import check
+
+// TESTCASE NUMBER: 0
+fun foo() = run { false && JavaClass.VALUE && throw Exception() }
+
+// TESTCASE NUMBER: 1
+fun case1() {
+    val a: Boolean? = false
+    checkSubtype<Boolean?>(a)
+    val x4 = a && true
+    x4 <!AMBIGUITY!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>check<!><Boolean>() }
+}
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val a: Any = false
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>a<!>
+    val x4 = a && true
+    x4 <!AMBIGUITY!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>check<!><Boolean>() }
+}
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    val a1 = false
+    val a2 = JavaClass.VALUE
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any..kotlin.Any?!")!>a2<!>
+
+    val x3 = a1 && a2
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Boolean")!>x3<!>
+
+    x3 <!AMBIGUITY!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>check<!><Boolean>() }
+}
+
+// TESTCASE NUMBER: 4
+fun case4() {
+    var x = false &&<!SYNTAX!><!> ;
+}
+
+// TESTCASE NUMBER: 5
+fun case5() {
+    var y = false &&<!SYNTAX!><!>
+}
+
+// TESTCASE NUMBER: 5
+fun case5() {
+    var x =<!SYNTAX!><!> <!SYNTAX!>&&<!>
+}
+
+// TESTCASE NUMBER: 6
+fun case6() {
+    var x =<!SYNTAX!><!> <!SYNTAX!>&& false  && true<!>
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.fir.kt
new file mode 100644
index 00000000000..1ee9f6616e9
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.fir.kt
@@ -0,0 +1,57 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, logical-conjunction-expression -> paragraph 2 -> sentence 1
+ * RELEVANT PLACES: 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;
+
+public class JavaClass {
+    public static boolean VALUE;
+
+    public static Object VALUE_OBJ = true;
+
+    public Boolean getValue ()
+    { return new Boolean ("true"); }
+}
+
+// MODULE: mainModule(libModule)
+// FILE: KotlinClass.kt
+package mainModule
+import libModule.*
+import checkSubtype
+import checkType
+import check
+
+fun foo() = run { false && JavaClass.VALUE && throw Exception() }
+
+
+// TESTCASE NUMBER: 1
+fun case1() {
+    val a1 = false
+    val a2 = JavaClass.VALUE
+    val a3 = foo()
+    val a4 = JavaClass().getValue()
+    val a5 = JavaClass.VALUE_OBJ
+
+    checkSubtype<Boolean>(a1)
+    checkSubtype<Boolean>(a2)
+    checkSubtype<Boolean>(a3)
+    checkSubtype<Boolean>(a4)
+
+    val x3 = a1 && a2 && a3 && a4 && a5 as Boolean
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Boolean")!>x3<!>
+
+    x3 <!AMBIGUITY!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>check<!><Boolean>()}
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg/1.1.fir.kt
new file mode 100644
index 00000000000..dfe294ea8f2
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg/1.1.fir.kt
@@ -0,0 +1,81 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, logical-disjunction-expression -> paragraph 2 -> sentence 1
+ * RELEVANT PLACES: 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;
+
+public class JavaClass {
+    public static Object VALUE = false;
+}
+
+// MODULE: mainModule(libModule)
+// FILE: KotlinClass.kt
+package mainModule
+import libModule.*
+import checkSubtype
+import checkType
+import check
+
+// TESTCASE NUMBER: 0
+fun foo() = run { false || JavaClass.VALUE || throw Exception() }
+
+// TESTCASE NUMBER: 1
+fun case1() {
+    val a: Boolean? = false
+    checkSubtype<Boolean?>(a)
+    val x4 = a || true
+    x4 <!AMBIGUITY!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>check<!><Boolean>() }
+}
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val a: Any = false
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>a<!>
+    val x4 = a || true
+    x4 <!AMBIGUITY!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>check<!><Boolean>() }
+}
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    val a1 = false
+    val a2 = JavaClass.VALUE
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any..kotlin.Any?!")!>a2<!>
+
+    val x3 = a1 || a2
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Boolean")!>x3<!>
+
+    x3 <!AMBIGUITY!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>check<!><Boolean>() }
+}
+
+// TESTCASE NUMBER: 4
+fun case4() {
+    var x = false ||<!SYNTAX!><!> ;
+}
+
+// TESTCASE NUMBER: 5
+fun case5() {
+    var y = false ||<!SYNTAX!><!>
+}
+
+// TESTCASE NUMBER: 5
+fun case5() {
+    var x =<!SYNTAX!><!> <!SYNTAX!>||<!>
+}
+
+// TESTCASE NUMBER: 6
+fun case6() {
+    var x =<!SYNTAX!><!> <!SYNTAX!>|| false  || true<!>
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.fir.kt
new file mode 100644
index 00000000000..f5d470f6958
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.fir.kt
@@ -0,0 +1,57 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, logical-disjunction-expression -> paragraph 2 -> sentence 1
+ * RELEVANT PLACES: 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;
+
+public class JavaClass {
+    public static boolean VALUE;
+
+    public static Object VALUE_OBJ = true;
+
+    public Boolean getValue ()
+    { return new Boolean ("true"); }
+}
+
+// MODULE: mainModule(libModule)
+// FILE: KotlinClass.kt
+package mainModule
+import libModule.*
+import checkSubtype
+import checkType
+import check
+
+fun foo() = run { false || JavaClass.VALUE || throw Exception() }
+
+
+// TESTCASE NUMBER: 1
+fun case1() {
+    val a1 = false
+    val a2 = JavaClass.VALUE
+    val a3 = foo()
+    val a4 = JavaClass().getValue()
+    val a5 = JavaClass.VALUE_OBJ
+
+    checkSubtype<Boolean>(a1)
+    checkSubtype<Boolean>(a2)
+    checkSubtype<Boolean>(a3)
+    checkSubtype<Boolean>(a4)
+
+    val x3 = a1 || a2 || a3 || a4 || a5 as Boolean
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Boolean")!>x3<!>
+
+    x3 <!AMBIGUITY!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>check<!><Boolean>()}
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos/1.1.fir.kt
new file mode 100644
index 00000000000..8f047a779e9
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos/1.1.fir.kt
@@ -0,0 +1,65 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, multiplicative-expression -> paragraph 5 -> sentence 1
+ * RELEVANT PLACES: 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() }
+    operator fun times(o: Case1):Any? { TODO() }
+    operator fun div(o: Int): Any? { TODO() }
+    operator fun div(o: Case1): Any? { TODO() }
+    operator fun rem(o: Int): Any? { TODO() }
+    operator fun rem(o: Case1): Any? { TODO() }
+}
+
+fun case1() {
+    val a = Case1(1) * 1
+    val b = Case1(1) * Case1( 1)
+    val c = Case1(1) / 1
+    val d = Case1(1) / Case1( 1)
+    val e = Case1(1) % 1
+    val f = Case1(1) % Case1( 1)
+
+    a checkType { check<Any?>() }
+    b checkType { check<Any?>() }
+    c checkType { check<Any?>() }
+    d checkType { check<Any?>() }
+    e checkType { check<Any?>() }
+    f checkType { check<Any?>() }
+}
+
+// TESTCASE NUMBER: 2
+class Case2(var a: Int) {
+    operator fun times(o: Int): Nothing? { TODO() }
+    operator fun times(o: Case2):Nothing? { TODO() }
+    operator fun div(o: Int): Nothing? { TODO() }
+    operator fun div(o: Case2): Nothing? { TODO() }
+    operator fun rem(o: Int): Nothing? { TODO() }
+    operator fun rem(o: Case2): Nothing? { TODO() }
+}
+
+fun case2() {
+    val a = Case2(1) * 1
+    val b = Case2(1) * Case2( 1)
+    val c = Case2(1) / 1
+    val d = Case2(1) / Case2( 1)
+    val e = Case2(1) % 1
+    val f = Case2(1) % Case2( 1)
+
+    a checkType { check<Nothing?>() }
+    b checkType { check<Nothing?>() }
+    c checkType { check<Nothing?>() }
+    d checkType { check<Nothing?>() }
+    e checkType { check<Nothing?>() }
+    f checkType { check<Nothing?>() }
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos/1.1.fir.kt
new file mode 100644
index 00000000000..73f680db746
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos/1.1.fir.kt
@@ -0,0 +1,54 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, not-null-assertion-expression -> paragraph 2 -> sentence 1
+ * NUMBER: 1
+ * DESCRIPTION: If the type of e is non-nullable, not-null assertion expression e!! has no effect.
+ */
+
+// 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!!
+}
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val x = JavaClass.obj!!
+}
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    val a = false
+    val x = a!!
+}
+
+// TESTCASE NUMBER: 4
+fun case4() {
+    val x = "weds"!!
+}
+
+// TESTCASE NUMBER: 5
+fun case5(nothing: Nothing) {
+    val y = nothing!!
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos/1.1.fir.kt
new file mode 100644
index 00000000000..691c62bd8da
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos/1.1.fir.kt
@@ -0,0 +1,70 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: 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;
+
+public class JavaClass {
+    public static final String STR;
+    public static Object obj;
+}
+
+
+// MODULE: mainModule(libModule)
+// FILE: KotlinClass.kt
+package mainModule
+import libModule.*
+import checkSubtype
+
+
+// TESTCASE NUMBER: 1
+fun case1() {
+    val a = JavaClass.STR
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String & kotlin.String..kotlin.String?!")!>a<!>
+    val res = a!!
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String")!>res<!>
+}
+
+// TESTCASE NUMBER: 2
+fun case2() {
+    val a = JavaClass.obj
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any..kotlin.Any?!")!>a<!>
+    val x = a!!
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>x<!>
+}
+
+// TESTCASE NUMBER: 3
+fun case3() {
+    val a : Any? = false
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>a<!>
+    val x = a!!
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any")!>x<!>
+}
+
+// TESTCASE NUMBER: 4
+fun case4() {
+    val a : String? = "weds"
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>a<!>
+    val x = a!!
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String")!>x<!>
+}
+
+// TESTCASE NUMBER: 5
+fun case5(nothing: Nothing?) {
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing?")!>nothing<!>
+    val y = nothing!!
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing")!>y<!>
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg/1.1.fir.kt
new file mode 100644
index 00000000000..98bf3404229
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg/1.1.fir.kt
@@ -0,0 +1,44 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, prefix-expressions, prefix-decrement-expression -> paragraph 4 -> sentence 1
+ * RELEVANT PLACES: statements, assignments -> paragraph 3 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: check unsafe prefix decrement expression call for an assignable expression
+ */
+class A() {
+    var i = 0
+
+    operator fun dec(): A {
+        this.i--
+        return this
+    }
+}
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    var b: Case1? = Case1()
+    <!AMBIGUITY!>--<!>b?.a
+}
+
+
+class Case1() {
+    var a: A = A()
+}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    var b= Case2()
+    --b.a
+}
+
+class Case2() {
+    val a = A()
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg/2.1.fir.kt
new file mode 100644
index 00000000000..ef7d0cf1d4f
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg/2.1.fir.kt
@@ -0,0 +1,47 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, prefix-expressions, prefix-decrement-expression -> paragraph 5 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: check as the result of dec is assigned to A, the return type of inc must be a subtype of A.
+ */
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    var a = Case1()
+    val res: Any? = ++a
+}
+
+
+class Case1() {
+
+    operator fun inc(): B {
+        TODO()
+    }
+}
+
+class B() {}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    var a = Case2()
+    val res: Any? = ++a
+}
+
+class Case2() : C() {
+    var i = 0
+
+    operator fun inc(): C {
+        TODO()
+    }
+
+}
+
+open class C() {}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.fir.kt
new file mode 100644
index 00000000000..aa917314149
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.fir.kt
@@ -0,0 +1,44 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 4 -> sentence 1
+ * RELEVANT PLACES: statements, assignments -> paragraph 3 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: check unsafe prefix increment expression call for an assignable expression
+ */
+class A() {
+    var i = 0
+
+    operator fun inc(): A {
+        this.i++
+        return this
+    }
+}
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    var b: Case1? = Case1()
+    <!AMBIGUITY!>++<!>b?.a
+}
+
+
+class Case1() {
+    var a: A = A()
+}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    var b= Case2()
+    ++b.a
+}
+
+class Case2() {
+    val a = A()
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.fir.kt
new file mode 100644
index 00000000000..f7d32e5d2e4
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg/2.1.fir.kt
@@ -0,0 +1,47 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, prefix-expressions, prefix-increment-expression -> paragraph 5 -> sentence 2
+ * NUMBER: 1
+ * DESCRIPTION: check as the result of inc is assigned to A, the return type of inc must be a subtype of A.
+ */
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    var a = Case1()
+    val res: Any? = --a
+}
+
+
+class Case1() {
+
+    operator fun dec(): B {
+        TODO()
+    }
+}
+
+class B() {}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    var a = Case2()
+    val res: Any? = --a
+}
+
+class Case2() : C() {
+    var i = 0
+
+    operator fun dec(): C {
+        TODO()
+    }
+
+}
+
+open class C() {}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos/1.1.fir.kt
new file mode 100644
index 00000000000..4e8609f0009
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos/1.1.fir.kt
@@ -0,0 +1,40 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, range-expression -> paragraph 4 -> sentence 1
+ * RELEVANT PLACES: 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?{
+        TODO()
+    }
+}
+fun case1() {
+    val x = Case1() .. Case1()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing?")!>x<!>
+    x checkType { check<Nothing?>() }
+}
+
+
+// TESTCASE NUMBER: 2
+class Case2() {
+    operator fun rangeTo(o: Case2): Any?{
+        TODO()
+    }
+}
+fun case2() {
+    val x = Case2() .. Case2()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
+    x checkType { check<Any?>() }
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/3.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/3.1.fir.kt
new file mode 100644
index 00000000000..55019bd253b
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/3.1.fir.kt
@@ -0,0 +1,75 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, try-expression -> paragraph 1 -> sentence 3
+ * RELEVANT PLACES: 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()
+class ExcB() : Exception()
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    try <!SYNTAX!><!>val a = ""
+        <!UNRESOLVED_REFERENCE!>catch<!>(<!UNRESOLVED_REFERENCE!>e<!><!SYNTAX!>: Exception<!>) {}
+    }<!SYNTAX!><!>
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    try {
+        val a = ""
+    } catch (e: Exception)<!SYNTAX!><!>
+}
+
+// TESTCASE NUMBER: 3
+
+fun case3() {
+    try {
+        val a = ""
+        throwException()
+    } catch (e: java.lang.IllegalArgumentException) {
+
+    } catch (e: ExcB)<!SYNTAX!><!>
+}
+
+// TESTCASE NUMBER: 4
+
+fun case4() {
+    try {
+        throwException()
+    } catch (<!SYNTAX!><!>) {
+
+    }
+}
+
+// TESTCASE NUMBER: 5
+
+fun case5() {
+    try {
+        throwException()
+    } catch (e: ExcA, <!SYNTAX!>e2<!><!SYNTAX!><!> <!SYNTAX!>: ExcB)<!>
+    {}
+}
+
+
+// TESTCASE NUMBER: 6
+
+fun case6() {
+    try {
+        val a = ""
+        throwException()
+    } catch (e: java.lang.IllegalArgumentException) {
+    } catch (e: ExcA)<!SYNTAX!><!>
+    catch (e: ExcB) {
+    }
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/4.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/4.1.fir.kt
new file mode 100644
index 00000000000..abe731bb9af
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg/4.1.fir.kt
@@ -0,0 +1,45 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, try-expression -> paragraph 1 -> sentence 4
+ * RELEVANT PLACES: 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()
+class ExcB() : Exception()
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    try {
+        throwException()
+    } catch (e: ExcA) {
+    } finally {
+    } <!UNRESOLVED_REFERENCE!>catch<!> (<!UNRESOLVED_REFERENCE!>e<!><!SYNTAX!><!SYNTAX!><!>: ExcB)<!> {
+    }
+}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    try {
+        throwException()
+    } catch (e: ExcB) {
+    } finally
+<!SYNTAX!><!>}<!SYNTAX!><!>
+
+// TESTCASE NUMBER: 3
+
+fun case3() {
+    try {
+        throwException()
+    } finally
+<!SYNTAX!><!>}<!SYNTAX!><!>
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos/1.1.fir.kt
new file mode 100644
index 00000000000..d50a2ea1202
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos/1.1.fir.kt
@@ -0,0 +1,36 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE:expressions, try-expression -> paragraph 1 -> sentence 1
+ * RELEVANT PLACES: 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()
+
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    try {
+        throwException()
+    }finally {
+        "a"
+    }
+}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    try {
+        val a = throwException()
+    }catch (e: Exception) {
+        "a"
+    }
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos/2.1.fir.kt
new file mode 100644
index 00000000000..b863b3b1bfd
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos/2.1.fir.kt
@@ -0,0 +1,25 @@
+// !LANGUAGE: +NewInference
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * PLACE: expressions, try-expression -> paragraph 2 -> sentence 2
+ * RELEVANT PLACES: 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() {
+    var flag = false
+    try {
+        throw Exception()
+        flag = true
+    } catch (e: Exception) {
+        assert(!flag)
+    }
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos/1.1.fir.kt
new file mode 100644
index 00000000000..f6f76b235a7
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos/1.1.fir.kt
@@ -0,0 +1,27 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * PLACE: expressions, try-expression -> paragraph 5 -> sentence 1
+ * RELEVANT PLACES: 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 {
+    var flag = false
+    try {
+        flag = true
+    } catch (e: Exception) {
+       return "foo"
+    } finally {
+        return "FINALLY"
+    }
+    return "return"
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos/2.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos/2.1.fir.kt
new file mode 100644
index 00000000000..6d9fa884de1
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos/2.1.fir.kt
@@ -0,0 +1,31 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
+// SKIP_TXT
+
+/*
+ * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
+ *
+ * SPEC VERSION: 0.1-218
+ * PLACE: expressions, try-expression -> paragraph 5 -> sentence 2
+ * RELEVANT PLACES: 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
+ * ISSUES: KT-23680
+ */
+fun case1(): Int {
+    var a = 1
+    try {
+        throw Exception() //invalid UNREACHABLE_CODE diagnostic
+    } catch (e: Exception) {
+        a = 5
+        return++a
+    } finally {
+        return a
+    }
+    return 0
+}
diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg/1.1.fir.kt
new file mode 100644
index 00000000000..5f69d83e335
--- /dev/null
+++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg/1.1.fir.kt
@@ -0,0 +1,66 @@
+// !LANGUAGE: +NewInference
+// !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
+ * PLACE: expressions, try-expression -> paragraph 8 -> sentence 1
+ * RELEVANT PLACES: 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
+ */
+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)
+
+// TESTCASE NUMBER: 1
+
+fun case1() {
+    val tryVal: B<String> =
+    try {
+        throwExceptionA(false)
+        A("")
+    } catch (e: Exception) {
+        B("")
+    }
+
+
+}
+
+// TESTCASE NUMBER: 2
+
+fun case2() {
+    val tryVal: A<String> =
+    try {
+        throwExceptionA(false)
+        A("")
+    } catch (e: Exception) {
+        null
+    }
+}
+
+/*
+ * TESTCASE NUMBER: 3
+ * UNEXPECTED BEHAVIOUR
+ * ISSUES: KT-35494
+ */
+fun case3() {
+    val tryVal: A<Int> =
+    try {
+        throwExceptionA(false)
+        A(2)
+    } catch (e: ExcA) {
+        A(null) //diag duplication
+    } catch (e: ExcB) {
+        B(null) //diag duplication
+    }
+}
+
+class ExcA() : Exception()
+class ExcB() : Exception()