Merge pull request #10248 from som-snytt/tweak/12316

lrytz · web-flow · commit a10823d06806 · 2022-12-23T16:41:57.000+01:00
Minor refactor in ListSet to foreground guards and add test
diff --git a/build.sbt b/build.sbt
@@ -691,7 +691,7 @@ lazy val junit = project.in(file("test") / "junit")
     (Test / forkOptions) := (Test / forkOptions).value.withWorkingDirectory((ThisBuild / baseDirectory).value),
     (Test / testOnly / forkOptions) := (Test / testOnly / forkOptions).value.withWorkingDirectory((ThisBuild / baseDirectory).value),
     libraryDependencies ++= Seq(junitDep, junitInterfaceDep, jolDep),
-    testOptions += Tests.Argument(TestFrameworks.JUnit, "-a", "-v"),
+    testOptions += Tests.Argument(TestFrameworks.JUnit, "-a", "-v", "-s"),
     (Compile / unmanagedSourceDirectories) := Nil,
     (Test / unmanagedSourceDirectories) := List(baseDirectory.value),
     Test / headerSources := Nil,
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
@@ -82,18 +82,15 @@ sealed class ListSet[A] extends AbstractSet[A]
 
   override def ++(xs: GenTraversableOnce[A]): ListSet[A] =
     xs match {
-      // we want to avoid to use of iterator as it causes allocations
-      // during reverseList
-      case ls: ListSet[A] =>
-        if (ls eq this) this
-        else {
-          val lsSize = ls.size
-          if (lsSize == 0) this
-          else if (isEmpty) ls
+      case _: this.type    => this
+      case _ if xs.isEmpty => this
+      // we want to avoid using iterator as it causes allocations during reverseList
+      case ls: ListSet[A]  =>
+          if (isEmpty) ls
           else {
-            @tailrec def skip(ls: ListSet[A], count: Int): ListSet[A] = {
+            // optimize add non-empty ListSet
+            @tailrec def skip(ls: ListSet[A], count: Int): ListSet[A] =
               if (count == 0) ls else skip(ls.next, count - 1)
-            }
 
             @tailrec def containsLimited(n: ListSet[A], e: A, end: ListSet[A]): Boolean =
               (n ne end) && (e == n.elem || containsLimited(n.next, e, end))
@@ -104,6 +101,7 @@ sealed class ListSet[A] extends AbstractSet[A]
             // We hope to get some structural sharing so find the tail of the
             // ListSet that are `eq` (or if there are not any then the ends of the lists),
             // and we optimise the add to only iterate until we reach the common end
+            val lsSize    = ls.size
             val thisSize  = this.size
             val remaining = Math.min(thisSize, lsSize)
             var thisTail  = skip(this, thisSize - remaining)
@@ -151,16 +149,13 @@ sealed class ListSet[A] extends AbstractSet[A]
                 case 4 => pending3
                 case _ => pending(pendingCount - 5)
               }
-              val r       = result
+              val r = result
               result = new r.Node(elem)
               pendingCount -= 1
             }
             result
           }
-        }
-      case _              =>
-        if (xs.isEmpty) this
-        else (repr /: xs) (_ + _)
+      case _               => xs.foldLeft(repr)(_ + _)
     }
 
   def iterator: Iterator[A] = {
diff --git a/test/junit/scala/collection/immutable/ListSetTest.scala b/test/junit/scala/collection/immutable/ListSetTest.scala
@@ -1,10 +1,12 @@
 package scala.collection.immutable
 
-import org.junit.Assert._
+import org.junit.Assert.{fail => _, _}
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 
+import scala.tools.testing.AssertUtil._
+
 @RunWith(classOf[JUnit4])
 class ListSetTest {
 
@@ -56,6 +58,11 @@ class ListSetTest {
   @Test
   def hasCorrectOrderAfterPlusPlus(): Unit = {
     val foo = ListSet(1)
+
+    assertSame(foo, foo ++ foo)
+    assertSame(foo, foo ++ ListSet.empty)
+    assertSame(foo, foo ++ Nil)
+
     var bar = foo ++ ListSet()
     assertEquals(List(1), bar.iterator.toList)
 
@@ -79,6 +86,13 @@ class ListSetTest {
 
     bar = foo ++ ListSet(1, 2, 3, 4, 5, 6)
     assertEquals(List(1, 2, 3, 4, 5, 6), bar.iterator.toList)
+    assertSameElements(List(1, 2, 3, 4, 5, 6), bar.iterator)
+  }
+  @Test
+  def `t12316 ++ is correctly ordered`(): Unit = {
+    // was: ListSet(1, 2, 3, 42, 43, 44, 29, 28, 27, 12, 11, 10)
+    assertEquals(ListSet(1,2,3,42,43,44,10,11,12,27,28,29), ListSet(1,2,3,42,43,44) ++ ListSet(10,11,12,42,43,44,27,28,29))
+    assertSameElements(List(1,2,3,42,43,44,10,11,12,27,28,29), ListSet(1,2,3,42,43,44) ++ ListSet(10,11,12,42,43,44,27,28,29))
   }
 
   @Test
