MACRO: check macro expansion depth during type inference

src/main/kotlin/org/rust/lang/core/types/infer/TypeInference.kt

@@ -814,4 +814,5 @@ object TypeInferenceMarks {
     val methodPickDerefOrder = Testmark("methodPickDerefOrder")
     val methodPickCollapseTraits = Testmark("methodPickCollapseTraits")
     val traitSelectionSpecialization = Testmark("traitSelectionSpecialization")
+    val macroExprDepthLimitReached = Testmark("reachMacroExprDepthLimit")
 }

src/main/kotlin/org/rust/lang/core/types/infer/TypeInferenceWalker.kt

@@ -31,6 +31,7 @@ class RsTypeInferenceWalker(
 ) {
     private var tryTy: Ty? = returnTy
     private var yieldTy: Ty? = null
+    private var macroExprDepth: Int = 0
     private val lookup get() = ctx.lookup
     private val items get() = ctx.items
     private val fulfill get() = ctx.fulfill
@@ -1046,6 +1047,19 @@ class RsTypeInferenceWalker(
     }
 
     private fun inferMacroExprType(macroExpr: RsMacroExpr, expected: Ty?): Ty {
+        if (macroExprDepth > DEFAULT_RECURSION_LIMIT) {
+            TypeInferenceMarks.macroExprDepthLimitReached.hit()
+            return TyUnknown
+        }
+        macroExprDepth++
+        try {
+            return inferMacroExprType0(macroExpr, expected)
+        } finally {
+            macroExprDepth--
+        }
+    }
+
+    private fun inferMacroExprType0(macroExpr: RsMacroExpr, expected: Ty?): Ty {
         val macroCall = macroExpr.macroCall
         val name = macroCall.macroName
         val exprArg = macroCall.exprMacroArgument

src/test/kotlin/org/rust/lang/core/type/RsMacroTypeInferenceTest.kt

@@ -5,6 +5,8 @@
 
 package org.rust.lang.core.type
 
+import org.rust.lang.core.types.infer.TypeInferenceMarks
+
 class RsMacroTypeInferenceTest : RsTypificationTestBase() {
     override val followMacroExpansions: Boolean get() = true
 
@@ -124,4 +126,12 @@ class RsMacroTypeInferenceTest : RsTypificationTestBase() {
             b;
         } //^ <unknown>
     """)
+
+    fun `test infinite recursion`() = testExpr("""
+        macro_rules! foo { () => { foo!(); }; }
+        fn main() {
+            let a = foo!();
+            a;
+        } //^ <unknown>
+    """, TypeInferenceMarks.macroExprDepthLimitReached)
 }