Fail early if self-referential LazyList runs out of elements

Port of scala/scala#8635.

Co-authored-by: NthPortal <nthportal@gmail.com>

Author: ijuma

compat/src/main/scala-2.11_2.12/scala/collection/compat/immutable/LazyList.scala

@@ -231,9 +231,16 @@ final class LazyList[+A] private (private[this] var lazyState: () => LazyList.St
 
   @volatile private[this] var stateEvaluated: Boolean = false
   @inline private def stateDefined: Boolean           = stateEvaluated
+  private[this] var midEvaluation = false
 
   private lazy val state: State[A] = {
-    val res = lazyState()
+    // if it's already mid-evaluation, we're stuck in an infinite
+    // self-referential loop (also it's empty)
+    if (midEvaluation) {
+      throw new RuntimeException("self-referential LazyList or a derivation thereof has no more elements")
+    }
+    midEvaluation = true
+    val res = try lazyState() finally midEvaluation = false
     // if we set it to `true` before evaluating, we may infinite loop
     // if something expects `state` to already be evaluated
     stateEvaluated = true

compat/src/test/scala/test/scala/collection/LazyListTest.scala

@@ -355,4 +355,25 @@ class LazyListTest {
     assertEquals(1 to 10, build(_ ++= LazyList.from(1).take(10)))
     assertEquals(1 to 10, build(_ ++= Iterator.from(1).take(10)))
   }
+
+  @Test
+  def selfReferentialFailure(): Unit = {
+    def assertNoStackOverflow[A](lazyList: LazyList[A]): Unit = {
+      // don't hang the test if we've made a programming error in this test
+      val finite = lazyList.take(1000)
+      // AssertUtil.assertThrows[RuntimeException](finite.force, _ contains "self-referential")
+      try {
+        finite.force
+        fail("Expected RuntimeException to be thrown")
+      } catch { case e: RuntimeException => assertTrue(e.getMessage.contains("self-referential")) }
+    }
+    assertNoStackOverflow { class L { val ll: LazyList[Nothing] = LazyList.empty #::: ll }; (new L).ll }
+    assertNoStackOverflow { class L { val ll: LazyList[Int] = 1 #:: ll.map(_ + 1).filter(_ % 2 == 0) }; (new L).ll }
+    class L {
+      lazy val a: LazyList[Nothing] = LazyList.empty #::: b
+      lazy val b: LazyList[Nothing] = LazyList.empty #::: a
+    }
+    assertNoStackOverflow((new L).a)
+    assertNoStackOverflow((new L).b)
+  }
 }