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

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -3125,6 +3125,12 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM) { firDiagnostic ->
+        TypecheckerHasRunIntoRecursiveProblemImpl(
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
     add(FirErrors.UNSAFE_CALL) { firDiagnostic ->
         UnsafeCallImpl(
             firSymbolBuilder.typeBuilder.buildKtType(firDiagnostic.a),

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -2184,6 +2184,10 @@ sealed class KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         override val diagnosticClass get() = SenselessNullInWhen::class
     }
 
+    abstract class TypecheckerHasRunIntoRecursiveProblem : KtFirDiagnostic<KtExpression>() {
+        override val diagnosticClass get() = TypecheckerHasRunIntoRecursiveProblem::class
+    }
+
     abstract class UnsafeCall : KtFirDiagnostic<PsiElement>() {
         override val diagnosticClass get() = UnsafeCall::class
         abstract val receiverType: KtType

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -2629,6 +2629,11 @@ internal class SenselessNullInWhenImpl(
     override val token: KtLifetimeToken,
 ) : KtFirDiagnostic.SenselessNullInWhen(), KtAbstractFirDiagnostic<KtElement>
 
+internal class TypecheckerHasRunIntoRecursiveProblemImpl(
+    override val firDiagnostic: KtPsiDiagnostic,
+    override val token: KtLifetimeToken,
+) : KtFirDiagnostic.TypecheckerHasRunIntoRecursiveProblem(), KtAbstractFirDiagnostic<KtExpression>
+
 internal class UnsafeCallImpl(
     override val receiverType: KtType,
     override val receiverExpression: KtExpression?,

compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/implicitTypes.kt

@@ -4,4 +4,4 @@ fun foo() = use(::bar)
 fun bar(x: String) = 1
 
 fun loop1() = <!INAPPLICABLE_CANDIDATE!>use<!>(::<!UNRESOLVED_REFERENCE!>loop2<!>)
-fun loop2() = loop1()
+fun loop2() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>loop1()<!>

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -1114,6 +1114,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<Boolean>("compareResult")
         }
         val SENSELESS_NULL_IN_WHEN by warning<KtElement>()
+        val TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM by error<KtExpression>()
     }
 
     val NULLABILITY by object : DiagnosticGroup("Nullability") {

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -592,6 +592,7 @@ object FirErrors {
     val UNREACHABLE_CODE by warning2<KtElement, Set<KtSourceElement>, Set<KtSourceElement>>(SourceElementPositioningStrategies.UNREACHABLE_CODE)
     val SENSELESS_COMPARISON by warning2<KtExpression, FirExpression, Boolean>()
     val SENSELESS_NULL_IN_WHEN by warning0<KtElement>()
+    val TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM by error0<KtExpression>()
 
     // Nullability
     val UNSAFE_CALL by error2<PsiElement, ConeKotlinType, FirExpression?>(SourceElementPositioningStrategies.DOT_BY_QUALIFIED)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt

@@ -21,7 +21,8 @@ object CommonExpressionCheckers : ExpressionCheckers() {
         get() = setOf(
             FirUnderscoreChecker,
             FirExpressionAnnotationChecker,
-            FirDeprecationChecker
+            FirDeprecationChecker,
+            FirRecursiveProblemChecker
         )
 
     override val qualifiedAccessCheckers: Set<FirQualifiedAccessChecker>

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirRecursiveProblemChecker.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.expression
+
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.types.*
+
+object FirRecursiveProblemChecker : FirBasicExpressionChecker() {
+    override fun check(expression: FirStatement, context: CheckerContext, reporter: DiagnosticReporter) {
+        if (expression !is FirExpression) return
+
+        fun checkConeType(coneType: ConeKotlinType?) {
+            if (coneType is ConeErrorType && (coneType.diagnostic as? ConeSimpleDiagnostic)?.kind == DiagnosticKind.RecursionInImplicitTypes) {
+                reporter.reportOn(expression.source, FirErrors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, context)
+            } else if (coneType is ConeClassLikeType) {
+                for (typeArgument in coneType.typeArguments) {
+                    checkConeType(typeArgument.type)
+                }
+            }
+        }
+
+        checkConeType(expression.typeRef.coneType)
+    }
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt

@@ -486,6 +486,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOO_MANY_ARGUMENT
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOPLEVEL_TYPEALIASES_ONLY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPEALIAS_SHOULD_EXPAND_TO_CLASS
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_ARGUMENTS_NOT_ALLOWED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_ARGUMENTS_REDUNDANT_IN_SUPER_QUALIFIER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_CANT_BE_USED_FOR_CONST_VAL
@@ -1474,6 +1475,7 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
         map.put(VARIABLE_WITH_NO_TYPE_NO_INITIALIZER, "This variable must either have a type annotation or be initialized")
 
         map.put(INITIALIZATION_BEFORE_DECLARATION, "Variable cannot be initialized before declaration", SYMBOL)
+        map.put(TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, "Type checking has run into a recursive problem. Easiest workaround: specify types of your declarations explicitly")
 
         map.put(MUST_BE_INITIALIZED, "Property must be initialized")
         map.put(MUST_BE_INITIALIZED_OR_BE_ABSTRACT, "Property must be initialized or be abstract")

compiler/testData/diagnostics/tests/RecursiveTypeInference.fir.kt

@@ -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
 

compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.fir.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

compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt

@@ -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

compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.fir.kt

@@ -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

compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.kt

@@ -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

compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.fir.kt

@@ -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
 }

compiler/testData/diagnostics/tests/delegatedProperty/kt48546.fir.kt

@@ -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"
     }
-}
+}

compiler/testData/diagnostics/tests/delegatedProperty/kt48546Strict.fir.kt

@@ -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"
     }
-}
+}

compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.fir.kt

@@ -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 {

compiler/testData/diagnostics/tests/delegation/kt48546.fir.kt

@@ -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"
     }
-}
+}

compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.fir.kt

@@ -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()<!> }

compiler/testData/diagnostics/tests/j+k/recursionWithJavaSyntheticProperty.fir.kt

@@ -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<!>
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt

@@ -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 ' '
             }
 

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt

@@ -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<!>
 }

compiler/testData/diagnostics/tests/regressions/Jet81.fir.kt

@@ -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
 }

compiler/testData/diagnostics/tests/regressions/ea76264.fir.kt

@@ -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<!>

compiler/testData/diagnostics/tests/regressions/kt328.fir.kt

@@ -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}!><!>
 

compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.fir.kt

@@ -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<!>()
         }
     }