Merge remote-tracking branch 'upstream/2.12.x' into opt/heuristics

4 files changed, 155 insertions, 1 deletions

diff --git a/test/junit/scala/collection/immutable/SetTests.scala b/test/junit/scala/collection/immutable/SetTests.scala
new file mode 100644
index 0000000000..28c7864359
--- /dev/null
+++ b/test/junit/scala/collection/immutable/SetTests.scala
@@ -0,0 +1,81 @@
+package scala.collection.immutable
+
+import org.junit.Assert._
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(classOf[JUnit4])
+class SetTests {
+  @Test
+  def test_SI8346_toSet_soundness(): Unit = {
+    val any2stringadd = "Disabled string conversions so as not to get confused!"
+    
+    def any[A](set: Set[A]): Set[Any] = {
+      val anyset = set.toSet[Any]
+      assert((anyset + "fish") contains "fish")
+      anyset
+    }
+
+    // Make sure default immutable Set does not rebuild itself on widening with toSet
+    // Need to cover 0, 1, 2, 3, 4 elements as special cases
+    var si = Set.empty[Int]
+    assert(si eq si.toSet[Any])
+    for (i <- 1 to 5) {
+      val s1 = Set(Array.range(1, i+1): _*)
+      val s2 = si + i
+      val s1a = any(s1)
+      val s2a = any(s2)
+      assert(s1 eq s1a)
+      assert(s2 eq s2a)
+      si = s2
+    }
+
+    // Make sure BitSet correctly rebuilds itself on widening with toSet
+    // Need to cover empty, values 0-63, values 0-127 as special cases
+    val bitsets = Seq(BitSet.empty, BitSet(23), BitSet(23, 99), BitSet(23, 99, 141))
+    bitsets.foreach{ b =>
+      val ba = any(b)
+      assert(b ne ba)
+      assertEquals(b, ba)
+    }
+
+    // Make sure HashSet (and by extension, its implementing class HashTrieSet)
+    // does not rebuild itself on widening by toSet
+    val hashset = HashSet(1, 3, 5, 7)
+    val hashseta = any(hashset)
+    assert(hashset eq hashseta)
+
+    // Make sure ListSet does not rebuild itself on widening by toSet
+    // (Covers Node also, since it subclasses ListSet)
+    val listset = ListSet(1, 3, 5, 7)
+    val listseta = any(listset)
+    assert(listset eq listseta)
+
+    // Make sure SortedSets correctly rebuild themselves on widening with toSet
+    // Covers TreeSet and keySet of SortedMap also
+    val sortedsets = Seq(
+      SortedSet.empty[Int], SortedSet(5), SortedSet(1,2,3,5,4),
+      SortedMap(1 -> "cod", 2 -> "herring").keySet
+    )
+    sortedsets.foreach{ set => 
+      val seta = any(set)
+      assert(set ne seta)
+      assertEquals(set, seta)
+    }
+
+    // Make sure ValueSets correctly rebuild themselves on widening with toSet
+    object WeekDay extends Enumeration {
+      type WeekDay = Value
+      val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value
+    }
+    val valuesa = any(WeekDay.values)
+    assert(WeekDay.values ne valuesa)
+    assertEquals(WeekDay.values, valuesa)
+
+    // Make sure regular Map keySets do not rebuild themselves on widening with toSet
+    val mapset = Map(1 -> "cod", 2 -> "herring").keySet
+    val mapseta = any(mapset)
+    assert(mapset eq mapseta)
+  }
+}
diff --git a/test/junit/scala/collection/immutable/StreamTest.scala b/test/junit/scala/collection/immutable/StreamTest.scala
index fad4e502eb..1b257aabc4 100644
--- a/test/junit/scala/collection/immutable/StreamTest.scala
+++ b/test/junit/scala/collection/immutable/StreamTest.scala
@@ -107,4 +107,20 @@ class StreamTest {
   def withFilter_map_properly_lazy_in_tail: Unit = {
     assertStreamOpLazyInTail(_.withFilter(_ % 2 == 0).map(identity), List(1, 2))
   }
+
+  @Test
+  def test_si9379() {
+    class Boom {
+      private var i = -1
+      def inc = {
+        i += 1
+        if (i > 1000) throw new NoSuchElementException("Boom! Too many elements!")
+        i
+      }
+    }
+    val b = new Boom
+    val s = Stream.continually(b.inc)
+    // zipped.toString must allow s to short-circuit evaluation
+    assertTrue((s, s).zipped.toString contains s.toString)
+  }
 }
diff --git a/test/junit/scala/runtime/ScalaRunTimeTest.scala b/test/junit/scala/runtime/ScalaRunTimeTest.scala
index 9da197c71a..728d8c0ce9 100644
--- a/test/junit/scala/runtime/ScalaRunTimeTest.scala
+++ b/test/junit/scala/runtime/ScalaRunTimeTest.scala
@@ -67,4 +67,61 @@ class ScalaRunTimeTest {
     val c = new C()
     assertFalse(c.toString, isTuple(c))
   }
+
+  @Test
+  def testStingOf() {
+    import ScalaRunTime.stringOf
+    import scala.collection._
+    import parallel.ParIterable
+
+    assertEquals("null", stringOf(null))
+    assertEquals( "\"\"", stringOf(""))
+
+    assertEquals("abc", stringOf("abc"))
+    assertEquals("\" abc\"", stringOf(" abc"))
+    assertEquals("\"abc \"", stringOf("abc "))
+
+    assertEquals("""Array()""", stringOf(Array.empty[AnyRef]))
+    assertEquals("""Array()""", stringOf(Array.empty[Int]))
+    assertEquals("""Array(1, 2, 3)""", stringOf(Array(1, 2, 3)))
+    assertEquals("""Array(a, "", " c", null)""", stringOf(Array("a", "", " c", null)))
+    assertEquals("""Array(Array("", 1, Array(5)), Array(1))""",
+        stringOf(Array(Array("", 1, Array(5)), Array(1))))
+
+    val map = Map(1->"", 2->"a", 3->" a", 4->null)
+    assertEquals(s"""${map.stringPrefix}(1 -> "", 2 -> a, 3 -> " a", 4 -> null)""", stringOf(map))
+    assertEquals(s"""${map.stringPrefix}(1 -> "", 2 -> a)""", stringOf(map, 2))
+
+    val iterable = Iterable("a", "", " c", null)
+    assertEquals(s"""${iterable.stringPrefix}(a, "", " c", null)""", stringOf(iterable))
+    assertEquals(s"""${iterable.stringPrefix}(a, "")""", stringOf(iterable, 2))
+
+    val parIterable = ParIterable("a", "", " c", null)
+    assertEquals(s"""${parIterable.stringPrefix}(a, "", " c", null)""", stringOf(parIterable))
+    assertEquals(s"""${parIterable.stringPrefix}(a, "")""", stringOf(parIterable, 2))
+
+    val traversable = new Traversable[Int] {
+       def foreach[U](f: Int => U): Unit = (0 to 3).foreach(f)
+    }
+    assertEquals(s"${traversable.stringPrefix}(0, 1, 2, 3)", stringOf(traversable))
+    assertEquals(s"${traversable.stringPrefix}(0, 1)", stringOf(traversable, 2))
+
+    val tuple1 = Tuple1(0)
+    assertEquals("(0,)", stringOf(tuple1))
+    assertEquals("(0,)", stringOf(tuple1, 0))
+
+    val tuple2 = Tuple2(0, 1)
+    assertEquals("(0,1)", stringOf(tuple2))
+    assertEquals("(0,1)", stringOf(tuple2, 0))
+
+    val tuple3 = Tuple3(0, 1, 2)
+    assertEquals("(0,1,2)", stringOf(tuple3))
+    assertEquals("(0,1,2)", stringOf(tuple3, 0))
+
+    val x = new Object {
+        override def toString(): String = "this is the stringOf string"
+    }
+    assertEquals(stringOf(x), "this is the stringOf string")
+    assertEquals(stringOf(x, 2), "this is the stringOf string")
+  }
 }
diff --git a/test/junit/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerTest.scala b/test/junit/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerTest.scala
index 72f26d231d..155e0a6017 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerTest.scala
@@ -205,7 +205,7 @@ class ProdConsAnalyzerTest extends ClearAfterClass {
   def iincProdCons(): Unit = {
     import Opcodes._
     val m = genMethod(descriptor = "(I)I")(
-      Incr(IINC, 1, 1), // producer and cosumer of local variable 1
+      Incr(IINC, 1, 1), // producer and consumer of local variable 1
       VarOp(ILOAD, 1),
       Op(IRETURN)
     )