test(callable): pin that resolving inside a for-generated ExUnit test terminates

Deciding whether a `test` generated inside a `for` comprehension is an
ExUnit.Case child resolves that call, which walks back up into the same `for`
and down into its children again. Two generated tests are needed to close the
loop: with one, the only element the walk would revisit is the entrance the
resolve state was seeded with.

Removing the RecursionManager guard on resolveInScope puts this fixture back on
the errors reported in #3405, which nothing else on the path prevents - both
hasBeenVisited guards read a ResolveState, and the reference boundary the cycle
crosses carries none.

Author: sh41

testData/org/elixir_lang/reference/callable/issue_3405/ex_unit_case.ex

@@ -0,0 +1,21 @@
+defmodule ExUnit.Case do
+  defmacro __using__(_opts) do
+    quote do
+      import ExUnit.Case
+    end
+  end
+
+  defmacro describe(message, do: block) do
+    quote do
+      unquote(message)
+      unquote(block)
+    end
+  end
+
+  defmacro test(message, do: block) do
+    quote do
+      unquote(message)
+      unquote(block)
+    end
+  end
+end

testData/org/elixir_lang/reference/callable/issue_3405/for_generated_ex_unit_tests.exs

@@ -0,0 +1,29 @@
+defmodule PhoneNumberPoolingTest do
+  use ExUnit.Case
+
+  describe "available_or_purchased_number/3" do
+    for test_case <- [
+          %{partition_strategy: "area_code", expected_phone_number: "+15550000001"},
+          %{partition_strategy: "toll_free", expected_phone_number: "+18005550002"}
+        ] do
+      @partition_strategy test_case.partition_strategy
+      @expected_phone_number test_case.expected_phone_number
+
+      test "sets webhooks on a " <> @partition_strategy <> "-type phone_number_pools record" do
+        assert available_or_purchased_number(random_pool_name<caret>()) == @expected_phone_number
+      end
+
+      test "informs caller that no numbers are available for " <> @partition_strategy do
+        assert available_or_purchased_number(random_pool_name()) == @expected_phone_number
+      end
+    end
+  end
+
+  defp random_pool_name do
+    "pool"
+  end
+
+  defp available_or_purchased_number(pool_name) do
+    pool_name
+  end
+end

tests/org/elixir_lang/reference/callable/Issue3405Test.kt

@@ -0,0 +1,65 @@
+package org.elixir_lang.reference.callable
+
+import com.intellij.openapi.util.RecursionManager
+import com.intellij.psi.PsiPolyVariantReference
+import org.elixir_lang.PlatformTestCase
+
+/**
+ * https://github.com/KronicDeth/intellij-elixir/issues/3405
+ */
+class Issue3405Test : PlatformTestCase() {
+    override fun setUp() {
+        super.setUp()
+
+        // The cycle below is prevented rather than absent, so `mayCacheNow()` is false and the test
+        // fixture's default `assertOnMissedCache` would fail before any assertion here ran.
+        // `RecursionManager` documents this switch for "tests that check that the stack isn't
+        // overflown on invalid code", which is what this is. Production sets neither flag: there,
+        // `doPreventingRecursion` returns `null` and the reference simply resolves to nothing.
+        RecursionManager.disableMissedCacheAssertions(testRootDisposable)
+        RecursionManager.disableAssertOnRecursionPrevention(testRootDisposable)
+    }
+
+    /**
+     * A `for` comprehension generating ExUnit `test` calls puts `ex_unit.Case.isChild` and
+     * `For.treeWalkDown` on the same walk: deciding whether a generated `test` is an `ExUnit.Case`
+     * child resolves that call, and resolving it walks back up into the `for` and down into its
+     * children again.
+     *
+     * Neither hinge's `hasBeenVisited` guard closes this. Both read a `ResolveState`, and the
+     * reference boundary between them - `PsiPolyVariantReference.multiResolve` - carries none, so
+     * the far side re-enters at `call_definition_clause.MultiResolve.resolveResults` and starts from
+     * `ResolveState.initial()`. Seeding that fresh state with the entrance is enough while the `for`
+     * body holds one generated `test`; with two, the walk reaches the sibling, which is on no
+     * visited set, and the cycle closes. The reporter's file had two.
+     *
+     * What contains it is the element-keyed `RecursionManager` guard on
+     * `reference.resolver.Callable.resolveInScope`, which is scoped to the thread's stack rather
+     * than to a `ResolveState` and so survives that boundary. Removing it puts this fixture back on
+     * the reported errors.
+     *
+     * The plugin catches its own overflow and reports it through
+     * [org.elixir_lang.errorreport.Logger], so termination is asserted on what was logged rather
+     * than on a `StackOverflowError` reaching the test.
+     */
+    fun testResolvingInsideForGeneratedExUnitTestTerminates() {
+        val (resolveResults, loggedErrors) = captureLoggedErrors {
+            // `ex_unit_case.ex` has to be resolvable, or `Case.isChild` answers `false` off the
+            // `ExUnit.Case` lookup and the walk this pins is never entered.
+            val reference = myFixture
+                .getReferenceAtCaretPosition("for_generated_ex_unit_tests.exs", "ex_unit_case.ex")
+            assertInstanceOf(reference, PsiPolyVariantReference::class.java)
+
+            (reference as PsiPolyVariantReference).multiResolve(false)
+        }
+
+        val overflows = loggedErrors.filter { loggedError ->
+            "StackOverflow" in loggedError.message || "StackOverflow" in (loggedError.title ?: "")
+        }
+
+        assertEmpty("resolving through a `for`-generated ExUnit `test` overflowed the stack", overflows)
+        assertNotNull(resolveResults)
+    }
+
+    override fun getTestDataPath(): String = "testData/org/elixir_lang/reference/callable/issue_3405"
+}