Merge pull request #350 from ijuma/scala-2.13.3

Upgrade Scala to 2.13.3 and Scala.js to 1.1.1

Author: SethTisue

.travis.yml

@@ -7,15 +7,15 @@ language: scala
 scala:
   - 2.11.12
   - 2.12.12
-  - 2.13.2
+  - 2.13.3
 
 env:
   - SCALAJS_VERSION=       ADOPTOPENJDK=8
   - SCALAJS_VERSION=0.6.33 ADOPTOPENJDK=8
-  - SCALAJS_VERSION=1.1.0  ADOPTOPENJDK=8
+  - SCALAJS_VERSION=1.1.1  ADOPTOPENJDK=8
   - SCALAJS_VERSION=       ADOPTOPENJDK=11
   - SCALAJS_VERSION=0.6.33 ADOPTOPENJDK=11
-  - SCALAJS_VERSION=1.1.0  ADOPTOPENJDK=11
+  - SCALAJS_VERSION=1.1.1  ADOPTOPENJDK=11
 
 matrix:
 

build.sbt

@@ -49,7 +49,7 @@ lazy val junit = libraryDependencies += "com.novocode" % "junit-interface" % "0.
 
 lazy val scala211 = "2.11.12"
 lazy val scala212 = "2.12.12"
-lazy val scala213 = "2.13.2"
+lazy val scala213 = "2.13.3"
 
 lazy val compat = MultiScalaCrossProject(JSPlatform, JVMPlatform, NativePlatform)(
   "compat",

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

@@ -231,9 +231,18 @@ 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
@@ -358,7 +367,7 @@ final class LazyList[+A] private (private[this] var lazyState: () => LazyList.St
     newLL {
       if (isEmpty) suffix match {
         case lazyList: LazyList[B] => lazyList.state // don't recompute the LazyList
-        case _                     => stateFromIterator(suffix.toIterator)
+        case coll                  => stateFromIterator(coll.toIterator)
       } else sCons(head, tail lazyAppendedAll suffix)
     }
 
@@ -1257,7 +1266,7 @@ object LazyList extends SeqFactory[LazyList] {
      *  @param hd   The first element of the result lazy list
      *  @param tl   The remaining elements of the result lazy list
      */
-    def apply[A](hd: => A, tl: => LazyList[A]): LazyList[A] = newLL(sCons(hd, tl))
+    def apply[A](hd: => A, tl: => LazyList[A]): LazyList[A] = newLL(sCons(hd, newLL(tl.state)))
 
     /** Maps a lazy list to its head and tail */
     def unapply[A](xs: LazyList[A]): Option[(A, LazyList[A])] = #::.unapply(xs)
@@ -1270,7 +1279,7 @@ object LazyList extends SeqFactory[LazyList] {
     /** Construct a LazyList consisting of a given first element followed by elements
      *  from another LazyList.
      */
-    def #::[B >: A](elem: => B): LazyList[B] = newLL(sCons(elem, l()))
+    def #::[B >: A](elem: => B): LazyList[B] = newLL(sCons(elem, newLL(l().state)))
 
     /** Construct a LazyList consisting of the concatenation of the given LazyList and
      *  another LazyList.

compat/src/test/scala/test/scala/collection/LazyListLazinessTest.scala

@@ -2,6 +2,7 @@ package test.scala.collection
 
 import org.junit.Test
 import org.junit.Assert._
+import org.junit.Ignore
 
 import scala.collection.compat.immutable.LazyList
 import scala.collection.compat._
@@ -217,7 +218,7 @@ class LazyListLazinessTest {
   }
 
   @Test
-  def lazyAppendedAll_appendedAll_properlyLazy(): Unit = {
+  def lazyAppendedAll_properlyLazy(): Unit = {
     genericAppendedColl_properlyLazy(_ lazyAppendedAll _)
   }
 
@@ -715,6 +716,21 @@ class LazyListLazinessTest {
   //   assertLazyAllSkipping(op, 4)
   // }
 
+  private def genericCons_unapply_properlyLazy(
+      unapply: LazyList[Int] => Option[(Int, LazyList[Int])]): Unit = {
+    assertLazyAllSkipping(unapply, 1)
+  }
+
+  @Test
+  def cons_unapply_properlyLazy(): Unit = {
+    genericCons_unapply_properlyLazy(LazyList.cons.unapply)
+  }
+
+  @Test
+  def `#::_unapply_properlyLazy`(): Unit = {
+    genericCons_unapply_properlyLazy(LazyList.#::.unapply)
+  }
+
   /* factory laziness tests */
 
   @Test
@@ -776,24 +792,48 @@ class LazyListLazinessTest {
     assertRepeatedlyLazy(factory)
   }
 
-  @Test
-  def `#:: properlyLazy`(): Unit = {
-    val factory = lazyListFactory { init =>
+  private def genericCons_properlyLazy(cons: (=> Int, => LazyList[Int]) => LazyList[Int]): Unit = {
+    val headInitFactory = lazyListFactory { init =>
       def gen(index: Int): LazyList[Int] = {
         def elem(): Int = { init.evaluate(index); index }
         if (index >= LazinessChecker.count) LazyList.empty
-        // else elem() #:: gen(index + 1)
-        else gen(index + 1).#::(elem())
+        else cons(elem(), gen(index + 1))
       }
 
       gen(0)
     }
-    assertRepeatedlyLazy(factory)
+    assertRepeatedlyLazy(headInitFactory)
+
+    val tailInitFactory = lazyListFactory { init =>
+      def gen(index: Int): LazyList[Int] = {
+        if (index >= LazinessChecker.count) LazyList.empty
+        else {
+          init.evaluate(index)
+          cons(index, gen(index + 1))
+        }
+      }
+
+      LazyList.empty lazyAppendedAll gen(0) // prevent initial state evaluation
+    }
+    assertRepeatedlyLazy(tailInitFactory)
+  }
+
+  @Test
+  @Ignore // TODO: enable after upgrading to 2.13.4+
+  def cons_properlyLazy(): Unit = {
+    genericCons_properlyLazy(LazyList.cons(_, _))
+  }
+
+  @Test
+  @Ignore // TODO: enable after upgrading Scala.js to 1.1.2+
+  def `#::_properlyLazy`(): Unit = {
+    // genericCons_properlyLazy(_ #:: _)
+    genericCons_properlyLazy((hd, tl) => tl.#::(hd))
   }
 
   @Test
   def `#::: properlyLazy`(): Unit = {
-    val factory = lazyListFactory { init =>
+    val headInitFactory = lazyListFactory { init =>
       def gen(index: Int): LazyList[Int] = {
         def elem(): LazyList[Int] = LazyList.fill(1) { init.evaluate(index); index }
         if (index >= LazinessChecker.count) LazyList.empty
@@ -802,7 +842,20 @@ class LazyListLazinessTest {
 
       gen(0)
     }
-    assertRepeatedlyLazy(factory)
+    assertRepeatedlyLazy(headInitFactory)
+
+    val tailInitFactory = lazyListFactory { init =>
+      def gen(index: Int): LazyList[Int] = {
+        if (index >= LazinessChecker.count) LazyList.empty
+        else {
+          init.evaluate(index)
+          LazyList.fill(1)(index) #::: gen(index + 1)
+        }
+      }
+
+      LazyList.empty lazyAppendedAll gen(0) // prevent initial state evaluation
+    }
+    assertRepeatedlyLazy(tailInitFactory)
   }
 
   @Test

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

@@ -2,6 +2,7 @@ package test.scala.collection
 
 import org.junit.Test
 import org.junit.Assert._
+import org.junit.Ignore
 
 import scala.collection.compat.immutable.LazyList
 import scala.collection.compat._
@@ -148,6 +149,7 @@ class LazyListTest {
     assertEquals("LazyList(1)", l.toString)
   }
 
+  @Ignore // TODO enable once Scala.js is upgraded to 1.1.2+
   @Test
   def testLazyListToStringWhenLazyListHasCyclicReference: Unit = {
     lazy val cyc: LazyList[Int] = 1 #:: 2 #:: 3 #:: 4 #:: cyc
@@ -161,7 +163,7 @@ class LazyListTest {
     cyc.tail.tail.head
     assertEquals("LazyList(1, 2, 3, <not computed>)", cyc.toString)
     cyc.tail.tail.tail.head
-    assertEquals("LazyList(1, 2, 3, 4, <cycle>)", cyc.toString)
+    assertEquals("LazyList(1, 2, 3, 4, <not computed>)", cyc.toString)
     cyc.tail.tail.tail.tail.head
     assertEquals("LazyList(1, 2, 3, 4, <cycle>)", cyc.toString)
   }
@@ -355,4 +357,37 @@ 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)
+  }
+
+  // scala/bug#11931
+  @Test
+  def lazyAppendedAllExecutesOnce(): Unit = {
+    var count = 0
+    LazyList(1).lazyAppendedAll({ count += 1; Seq(2) }).toList
+    assertEquals(1, count)
+  }
 }