duplicate logic for LinearSeq

Author: Martijn Hoekstra

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

@@ -12,14 +12,15 @@
 
 package scala.collection.compat
 
+import scala.collection.LinearSeq
 import scala.collection.generic.CanBuildFrom
 import scala.collection.mutable.Builder
 import scala.collection.{immutable => i, mutable => m}
 
 /* builder optimized for a single ++= call, which returns identity on result if possible
  * and defers to the underlying builder if not.
  */
-private final class IdentityPreservingSeqBuilder[A, C <: Seq[A]](that: Builder[A, C])
+private final class IdentityPreservingSeqBuilder[A](that: Builder[A, Seq[A]])
     extends Builder[A, Seq[A]] {
   var collection: Seq[A] = null
   var ruined = false
@@ -50,6 +51,36 @@ private final class IdentityPreservingSeqBuilder[A, C <: Seq[A]](that: Builder[A
   final def result(): Seq[A] = if(ruined) that.result() else if (collection eq null) Nil else collection
 }
 
+private final class IdentityPreservingLinearSeqBuilder[A](that: Builder[A, LinearSeq[A]]) extends Builder[A, LinearSeq[A]] {
+  var collection: LinearSeq[A] = null
+  var ruined = false
+
+  final override def ++=(elems: TraversableOnce[A]): this.type =
+      if(!ruined && collection == null && elems.isInstanceOf[LinearSeq[_]]) {
+        collection = elems.asInstanceOf[LinearSeq[A]]
+        this
+      }
+      else {
+        ruined = true
+        if (collection != null) that ++= collection
+        that ++= elems
+        collection = null
+        this
+      }
+
+  final def +=(elem: A): this.type = {
+    collection = null
+    ruined = true
+    that += elem
+    this
+  }
+  final def clear(): Unit = {
+    collection = null
+    if (ruined) that.clear()
+  }
+  final def result(): LinearSeq[A] = if(ruined) that.result() else if (collection eq null) Nil else collection
+}
+
 private[compat] object CompatImpl {
   def simpleCBF[A, C](f: => Builder[A, C]): CanBuildFrom[Any, A, C] = new CanBuildFrom[Any, A, C] {
     def apply(from: Any): Builder[A, C] = apply()

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

@@ -14,7 +14,7 @@ package scala.collection.compat
 
 import scala.collection.generic._
 import scala.reflect.ClassTag
-import scala.collection.{MapLike, GenTraversable, BitSet, IterableView}
+import scala.collection.{LinearSeq, MapLike, GenTraversable, BitSet, IterableView}
 import scala.collection.{immutable => i, mutable => m}
 import scala.{collection => c}
 
@@ -46,7 +46,8 @@ private[compat] trait PackageShared {
 
   implicit def genericCompanionToCBF[A, CC[X] <: GenTraversable[X]](
       fact: GenericCompanion[CC]): CanBuildFrom[Any, A, CC[A]] = {
-    val builder = if (fact == Seq) new IdentityPreservingSeqBuilder[A, Seq[A]](Seq.newBuilder[A]).asInstanceOf[m.Builder[A, CC[A]]]
+    val builder = if (fact == Seq) new IdentityPreservingSeqBuilder[A](Seq.newBuilder[A]).asInstanceOf[m.Builder[A, CC[A]]]
+                  else if (fact == LinearSeq) new IdentityPreservingLinearSeqBuilder[A](LinearSeq.newBuilder[A]).asInstanceOf[m.Builder[A, CC[A]]]
                   else fact.newBuilder[A]
     simpleCBF(builder)
   }

compat/src/test/scala/test/scala/collection/CollectionTest.scala

@@ -17,6 +17,7 @@ import org.junit.Test
 
 import scala.collection.compat._
 import scala.collection.immutable.BitSet
+import scala.collection.LinearSeq
 
 class CollectionTest {
   @Test
@@ -44,6 +45,7 @@ class CollectionTest {
     // Stream.to(Seq) doesn't evaluate the stream
     val strm = 1 #:: {throw new Exception("not lazy")} #:: Stream.empty[Int]
     val strmsq: Seq[Int] = strm.to(Seq)
+    var strmln: LinearSeq[Int] = strm.to(LinearSeq)
   }
 
   @Test