Merge remote-tracking branch 'origin/master' into max-min-Option

Author: SethTisue

.travis.yml

@@ -6,31 +6,31 @@ language: scala
 
 scala:
   - 2.11.12
-  - 2.12.11
-  - 2.13.2
+  - 2.12.12
+  - 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:
 
   include:
 
     # run migration test
-    - scala: 2.12.11
+    - scala: 2.12.12
       env: TEST_SCALAFIX=true           ADOPTOPENJDK=8
 
     # run binary compatibility test
-    - scala: 2.12.11
+    - scala: 2.12.12
       env: TEST_BINARY_COMPAT=true      ADOPTOPENJDK=8
 
     # run scalafmt
-    - scala: 2.12.11
+    - scala: 2.12.12
       env: TEST_SCALAFMT=true           ADOPTOPENJDK=8
 
     # Scala Native includes

README.md

@@ -39,7 +39,7 @@ The library also adds backported versions of new collection types, currently `sc
 
 ## Migration Tool
 
-The migration rules use scalafix. Please see the [official installation instruction](https://scalacenter.github.io/scalafix/docs/users/installation.html) and, in particular, check that your full Scala version is supported (ex 2.12.11).
+The migration rules use scalafix. Please see the [official installation instruction](https://scalacenter.github.io/scalafix/docs/users/installation.html) and, in particular, check that your full Scala version is supported (ex 2.12.12).
 
 ```scala
 // project/plugins.sbt

build.sbt

@@ -48,8 +48,8 @@ lazy val root = project
 lazy val junit = libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % Test
 
 lazy val scala211 = "2.11.12"
-lazy val scala212 = "2.12.11"
-lazy val scala213 = "2.13.2"
+lazy val scala212 = "2.12.12"
+lazy val scala213 = "2.13.3"
 
 lazy val compat = MultiScalaCrossProject(JSPlatform, JVMPlatform, NativePlatform)(
   "compat",

compat/src/main/scala-2.11/scala/collection/compat/package.scala

@@ -15,7 +15,7 @@ package scala.collection
 import scala.collection.generic.{CanBuildFrom, GenericOrderedCompanion, IsTraversableLike}
 
 import scala.runtime.Tuple2Zipped
-import scala.collection.{immutable => i}
+import scala.collection.{immutable => i, mutable => m}
 import scala.{collection => c}
 
 package object compat extends compat.PackageShared {
@@ -58,4 +58,8 @@ package object compat extends compat.PackageShared {
       self: i.Queue[A]): ImmutableQueueExtensionMethods[A] =
     new ImmutableQueueExtensionMethods[A](self)
 
+  implicit def toMutableQueueExtensionMethods[A](
+      self: m.Queue[A]): MutableQueueExtensionMethods[A] =
+    new MutableQueueExtensionMethods[A](self)
+
 }

compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala

@@ -458,3 +458,8 @@ class ImmutableQueueExtensionMethods[A](private val self: i.Queue[A]) extends An
   def enqueueAll[B >: A](iter: c.Iterable[B]): i.Queue[B] =
     self.enqueue(iter.to[i.Iterable])
 }
+
+class MutableQueueExtensionMethods[Element](private val self: m.Queue[Element]) extends AnyVal {
+  def enqueueAll(iter: c.Iterable[Element]): Unit =
+    self.enqueue(iter.toIndexedSeq: _*)
+}

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/main/scala-2.12/scala/collection/compat/package.scala

@@ -14,7 +14,6 @@ package scala.collection
 
 import scala.collection.generic.{CanBuildFrom, GenericOrderedCompanion, IsTraversableLike}
 import scala.{collection => c}
-import scala.collection.{mutable => m}
 import scala.runtime.Tuple2Zipped
 import scala.collection.{immutable => i, mutable => m}
 
@@ -67,4 +66,8 @@ package object compat extends compat.PackageShared {
   implicit def toImmutableQueueExtensionMethods[A](
       self: i.Queue[A]): ImmutableQueueExtensionMethods[A] =
     new ImmutableQueueExtensionMethods[A](self)
+
+  implicit def toMutableQueueExtensionMethods[A](
+      self: m.Queue[A]): MutableQueueExtensionMethods[A] =
+    new MutableQueueExtensionMethods[A](self)
 }

compat/src/test/scala/test/scala/collection/ImmutableQueueTest.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/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._
@@ -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)
+  }
 }