[FIR] Add TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM diagnostics, ^KT-52327 Fixed

2022-06-01 00:29:32 +03:00
parent c5648fd449
commit 9f69ea1786
27 changed files with 109 additions and 50 deletions
@@ -2,23 +2,23 @@

 // FILE: a.kt
 package a
-    val foo = bar()
+    val foo = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>

-    fun bar() = foo
+    fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>

 // FILE: b.kt
 package b
-    fun foo() = bar()
+    fun foo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>

-    fun bar() = foo()
+    fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo()<!>

 // FILE: c.kt
 package c
-    fun bazz() = bar()
+    fun bazz() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>

-    fun foo() = bazz()
+    fun foo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bazz()<!>

-    fun bar() = foo()
+    fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo()<!>

 // FILE: d.kt

@@ -0,0 +1,4 @@
+// Functions can be recursively annotated
+annotation class ann(val x: Int)
+@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>bar()<!>) fun foo() = 1
+@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo()<!>) fun bar() = 2
@@ -1,5 +1,4 @@
-// FIR_IDENTICAL
 // Functions can be recursively annotated
 annotation class ann(val x: Int)
@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>bar()<!>) fun foo() = 1
-@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>foo()<!>) fun bar() = 2
+@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>foo()<!>) fun bar() = 2
@@ -0,0 +1,3 @@
+// Functions can be recursively annotated
+annotation class ann(val x: Int)
+@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo()<!>) fun foo() = 1
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // Functions can be recursively annotated
 annotation class ann(val x: Int)
-@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>foo()<!>) fun foo() = 1
+@ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>foo()<!>) fun foo() = 1
@@ -240,7 +240,7 @@ class Outer() {
 }

 class ForwardAccessToBackingField() { //kt-147
-    val a = a // error
+    val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!> // error
    val b = c // error
    val c = 1
 }
@@ -4,7 +4,7 @@
 object DelegateTest {
    var result = ""
    val f by lazy {
-        result += <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: cycle")!>f<!>.toString() // Compiler crash
+        result += <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: cycle"), TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>f<!>.toString() // Compiler crash
        "hello"
    }
 }
@@ -12,7 +12,7 @@ object DelegateTest {
 object DelegateTest2 {
    var result = ""
    val f by lazy {
-        result += <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: cycle")!>f<!>
+        result += <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: cycle"), TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>f<!>
        "hello"
    }
-}
+}
@@ -5,7 +5,7 @@
 object DelegateTest {
    var result = ""
    val f by lazy {
-        result += <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: cycle")!>f<!>.toString() // Compiler crash
+        result += <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: cycle"), TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>f<!>.toString() // Compiler crash
        "hello"
    }
 }
@@ -13,7 +13,7 @@ object DelegateTest {
 object DelegateTest2 {
    var result = ""
    val f by lazy {
-        result += <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: cycle")!>f<!>
+        result += <!DEBUG_INFO_EXPRESSION_TYPE("ERROR CLASS: cycle"), TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>f<!>
        "hello"
    }
-}
+}
@@ -3,12 +3,12 @@

 import kotlin.reflect.KProperty

-val a by <!RECURSION_IN_IMPLICIT_TYPES!>a<!>
+val a by <!RECURSION_IN_IMPLICIT_TYPES, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>

-val b by Delegate(b)
+val b by Delegate(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)

 val c by d
-val d by <!RECURSION_IN_IMPLICIT_TYPES!>c<!>
+val d by <!RECURSION_IN_IMPLICIT_TYPES, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>c<!>

 class Delegate(i: Int) {
  operator fun getValue(t: Any?, p: KProperty<*>): Int {
@@ -3,7 +3,7 @@
 object DelegateTest {
    var result = ""
    val f by lazy {
-        result += f.toString() // Compiler crash
+        result += <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>f<!>.toString() // Compiler crash
        "hello"
    }
-}
+}
@@ -12,7 +12,7 @@ fun insideJob1() = doTheJob1()
 suspend fun insideJob2() = doTheJob2()
 suspend fun insideJob3() = doTheJob3()

-fun doTheJob0() = simpleAsync0 { <!ARGUMENT_TYPE_MISMATCH!>insideJob0()<!> }
-fun doTheJob1() = simpleAsync1 { <!ARGUMENT_TYPE_MISMATCH!>insideJob1()<!> }
-suspend fun doTheJob2() = simpleAsync2 { <!ARGUMENT_TYPE_MISMATCH!><!NON_LOCAL_SUSPENSION_POINT!>insideJob2<!>()<!> }
-suspend fun doTheJob3() = simpleAsync3 { <!ARGUMENT_TYPE_MISMATCH!>insideJob3()<!> }
+fun doTheJob0() = simpleAsync0 { <!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob0()<!> }
+fun doTheJob1() = simpleAsync1 { <!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob1()<!> }
+suspend fun doTheJob2() = simpleAsync2 { <!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NON_LOCAL_SUSPENSION_POINT!>insideJob2<!>()<!> }
+suspend fun doTheJob3() = simpleAsync3 { <!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob3()<!> }
@@ -8,5 +8,5 @@ public class X {

 class A : X() {
    // TODO: DEBUG_INFO_MISSING_UNRESOLVED indicates a bug here
-    override fun getFoo() = foo
-}
+    override fun getFoo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
+}
@@ -6,7 +6,7 @@ object Outer {
                get() = 0

            override fun get(index: Int): Char {
-                checkSubtype<CharSequence>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+                checkSubtype<CharSequence>(<!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>x<!>)
                return ' '
            }

@@ -1,16 +1,16 @@
 // !CHECK_TYPE
 // NI_EXPECTED_FILE

-val x get() = x
+val x get() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>x<!>

 class A {
-    val y get() = y
+    val y get() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>y<!>

-    val a get() = b
-    val b get() = a
+    val a get() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>
+    val b get() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>

-    val z1 get() = id(<!ARGUMENT_TYPE_MISMATCH!>z1<!>)
-    val z2 get() = l(<!ARGUMENT_TYPE_MISMATCH!>z2<!>)
+    val z1 get() = id(<!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z1<!>)
+    val z2 get() = l(<!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z2<!>)

    val u get() = <!UNRESOLVED_REFERENCE!>field<!>
 }
@@ -3,10 +3,10 @@

 class Test {
  private val y = object {
-    val a = y;
+    val a = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>y<!>;
  }

-  val z = y.a;
+  val z = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>y.a<!>;

 }

@@ -23,6 +23,6 @@ class Test2 {
    val y = 1
  }

-  val b = a.<!UNRESOLVED_REFERENCE!>x<!>
+  val b = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>.<!UNRESOLVED_REFERENCE!>x<!>
  val c = a.y
 }
@@ -1,4 +1,4 @@
 // StackOverflow
-val p = ::p
+val p = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>::p<!>

-fun foo() = ::foo
+fun foo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>::foo<!>
@@ -2,28 +2,28 @@
 //KT-328 Local function in function literals cause exceptions

 fun bar1() = {
-    bar1()
+    <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar1()<!>
 }

 fun bar2() = {
-    fun foo2() = bar2()
+    fun foo2() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar2()<!>
 }

 //properties
 //in a class
 class A() {
-    val x = { x }
+    val x = { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>x<!> }
 }

 //in a package
-val x = { x }
+val x = { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>x<!> }

 //KT-787 AssertionError on code 'val x = x'
-val z = z
+val z = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z<!>

 //KT-329 Assertion failure on local function
 fun block(f : () -> Unit) = f()

 fun bar3() = block{ <!UNRESOLVED_REFERENCE!>foo3<!>() // <-- missing closing curly bracket
-fun foo3() = block{ bar3() }<!SYNTAX{PSI}!><!>
+fun foo3() = block{ <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar3()<!> }<!SYNTAX{PSI}!><!>

@@ -13,6 +13,6 @@ suspend fun fib(n: Long) =
    async {
        when {
            n < 2 -> n
-            else -> fib(n - 1).<!UNRESOLVED_REFERENCE!>await<!>() + fib(n - 2).<!UNRESOLVED_REFERENCE!>await<!>()
+            else -> <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>fib(n - 1)<!>.<!UNRESOLVED_REFERENCE!>await<!>() + <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>fib(n - 2)<!>.<!UNRESOLVED_REFERENCE!>await<!>()
        }
    }