Initial version

Author: szeiger

.gitignore

@@ -0,0 +1,15 @@
+/.settings/
+/.idea/
+target/
+*.log
+*.iml
+/\.target/
+/\.cache
+/\.project
+/\.classpath
+.history
+.DS_Store
+/tmp/
+/bin/
+/.cache-main
+/.cache-tests

README.md

@@ -0,0 +1,24 @@
+Scala 2.13 Collection Compatibility Library
+===========================================
+
+This library for Scala 2.12 provides limited compatibility with the new collection library in 2.13. We try to keep the
+2.13 collections as backward compatible as possible but that is not always possible. For some of these cases this
+library allows you to compile sources written for a subset of the new semantics of 2.13 on 2.12.
+
+For example, the `to` method is used with a type parameter in 2.12:
+
+```scala
+  xs.to[List]
+```
+
+With this compatibility library you can also use the 2.13 syntax which uses a companion object:
+
+```scala
+  import scala.collection.compat._
+  xs.to(List)
+```
+
+This project can be cross-built on 2.13 (with new collections) and 2.12. The 2.13 version consists only of an
+empty `scala.collection.compat` package object that allows you to write `import scala.collection.compat._` in 2.13. 
+The 2.13 version has the compatibility extensions in this package. It also adds backported version of some new collection
+types to other `scala.collection` subpackages.

build.sbt

@@ -0,0 +1,16 @@
+organization := "org.scala-lang"
+
+name := "scala-collection-compat"
+
+version := "0.1-SNAPSHOT"
+
+resolvers += "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-pr-validation-snapshots/"
+
+unmanagedSourceDirectories in Compile ++=
+  (if(scalaVersion.value.startsWith("2.13.")) Seq((sourceDirectory in Compile).value / "scala-2.13") else Seq())
+
+crossScalaVersions := Seq("2.12.4", "2.13.0-pre-08218cd-SNAPSHOT")
+
+scalaVersion := crossScalaVersions.value.head
+
+libraryDependencies += "com.novocode" % "junit-interface" % "0.11" % "test"

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.16

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

@@ -0,0 +1,40 @@
+package scala.collection
+
+import scala.collection.generic._
+import scala.collection.mutable.Builder
+import scala.reflect.ClassTag
+
+/** The collection compatibility API */
+package object compat {
+  import scala.collection.compat_impl._
+
+  implicit def genericCompanionToCBF[A, CC[X] <: GenTraversable[X]](fact: GenericCompanion[CC]): CanBuildFrom[Nothing, A, CC[A]] =
+    simpleCBF(fact.newBuilder[A])
+
+  implicit def arrayCompanionToCBF[A : ClassTag](fact: Array.type): CanBuildFrom[Nothing, A, Array[A]] =
+    simpleCBF(Array.newBuilder[A])
+
+  implicit def mapFactoryToCBF[K, V, CC[A, B] <: Map[A, B] with MapLike[A, B, CC[A, B]]](fact: MapFactory[CC]): CanBuildFrom[Nothing, (K, V), CC[K, V]] =
+    simpleCBF(fact.newBuilder[K, V])
+
+  implicit def immutableBitSetFactoryToCBF(fact: BitSetFactory[immutable.BitSet]): CanBuildFrom[Nothing, Int, ImmutableBitSetCC[Int]] =
+    simpleCBF(fact.newBuilder)
+
+  implicit def mutableBitSetFactoryToCBF(fact: BitSetFactory[mutable.BitSet]): CanBuildFrom[Nothing, Int, MutableBitSetCC[Int]] =
+    simpleCBF(fact.newBuilder)
+
+  implicit class IterableFactoryExtensionMethods[CC[X] <: GenTraversable[X]](private val fact: GenericCompanion[CC]) {
+    def from[A](source: TraversableOnce[A]): CC[A] = fact.apply(source.toSeq: _*)
+  }
+
+  implicit class MapFactoryExtensionMethods[CC[A, B] <: Map[A, B] with MapLike[A, B, CC[A, B]]](private val fact: MapFactory[CC]) {
+    def from[K, V](source: TraversableOnce[(K, V)]): CC[K, V] = fact.apply(source.toSeq: _*)
+  }
+
+  implicit class BitSetFactoryExtensionMethods[C <: scala.collection.BitSet with scala.collection.BitSetLike[C]](private val fact: BitSetFactory[C]) {
+    def fromSpecific(source: TraversableOnce[Int]): C = fact.apply(source.toSeq: _*)
+  }
+
+  // This really belongs into scala.collection but there's already a package object in scala-library so we can't add to it
+  type IterableOnce[+X] = TraversableOnce[X]
+}

src/main/scala-2.12/collection/compat_impl/package.scala

@@ -0,0 +1,15 @@
+package scala.collection
+
+import scala.collection.generic._
+import scala.collection.mutable.Builder
+import scala.reflect.ClassTag
+
+package object compat_impl {
+  def simpleCBF[A, C](f: => Builder[A, C]): CanBuildFrom[Nothing, A, C] = new CanBuildFrom[Nothing, A, C] {
+    def apply(from: Nothing): Builder[A, C] = apply()
+    def apply(): Builder[A, C] = f
+  }
+
+  type ImmutableBitSetCC[X] = ({ type L[_] = immutable.BitSet })#L[X]
+  type MutableBitSetCC[X] = ({ type L[_] = mutable.BitSet })#L[X]
+}

src/main/scala-2.12/collection/immutable/ImmutableArray.scala

@@ -0,0 +1,213 @@
+package scala
+package collection
+package immutable
+
+import scala.reflect.ClassTag
+import scala.runtime.BoxedUnit
+import scala.collection.generic._
+import scala.collection.mutable.{Builder, ArrayBuilder, ArrayBuffer, WrappedArrayBuilder}
+import scala.util.hashing.MurmurHash3
+import scala.annotation.unchecked.uncheckedVariance
+
+import java.util.Arrays
+
+/**
+  * An immutable array.
+  *
+  * Supports efficient indexed access and has a small memory footprint.
+  *
+  *  @define Coll `ImmutableArray`
+  *  @define coll wrapped array
+  *  @define orderDependent
+  *  @define orderDependentFold
+  *  @define mayNotTerminateInf
+  *  @define willNotTerminateInf
+  */
+abstract class ImmutableArray[+T]
+  extends AbstractSeq[T]
+    with IndexedSeq[T]
+{
+
+  override protected[this] def thisCollection: ImmutableArray[T] = this
+
+  /** The tag of the element type */
+  protected[this] def elemTag: ClassTag[T]
+
+  /** The length of the array */
+  def length: Int
+
+  /** The element at given index */
+  def apply(index: Int): T
+
+  /** The underlying array */
+  def unsafeArray: Array[T @uncheckedVariance]
+
+  private def elementClass: Class[_] =
+    unsafeArray.getClass.getComponentType
+
+  override def stringPrefix = "ImmutableArray"
+
+  /** Clones this object, including the underlying Array. */
+  override def clone(): ImmutableArray[T] = ImmutableArray unsafeWrapArray unsafeArray.clone()
+
+  /** Creates new builder for this collection ==> move to subclasses
+    */
+  override protected[this] def newBuilder: Builder[T, ImmutableArray[T]] =
+    new WrappedArrayBuilder[T](elemTag).mapResult(w => ImmutableArray.unsafeWrapArray(w.array))
+
+}
+
+/** A companion object used to create instances of `ImmutableArray`.
+  */
+object ImmutableArray {
+  // This is reused for all calls to empty.
+  private val EmptyImmutableArray  = new ofRef[AnyRef](new Array[AnyRef](0))
+  def empty[T <: AnyRef]: ImmutableArray[T] = EmptyImmutableArray.asInstanceOf[ImmutableArray[T]]
+
+  // If make is called explicitly we use whatever we're given, even if it's
+  // empty.  This may be unnecessary (if ImmutableArray is to honor the collections
+  // contract all empty ones must be equal, so discriminating based on the reference
+  // equality of an empty array should not come up) but we may as well be
+  // conservative since wrapRefArray contributes most of the unnecessary allocations.
+  def unsafeWrapArray[T](x: AnyRef): ImmutableArray[T] = (x match {
+    case null              => null
+    case x: Array[AnyRef]  => new ofRef[AnyRef](x)
+    case x: Array[Int]     => new ofInt(x)
+    case x: Array[Double]  => new ofDouble(x)
+    case x: Array[Long]    => new ofLong(x)
+    case x: Array[Float]   => new ofFloat(x)
+    case x: Array[Char]    => new ofChar(x)
+    case x: Array[Byte]    => new ofByte(x)
+    case x: Array[Short]   => new ofShort(x)
+    case x: Array[Boolean] => new ofBoolean(x)
+    case x: Array[Unit]    => new ofUnit(x)
+  }).asInstanceOf[ImmutableArray[T]]
+
+  implicit def canBuildFrom[T](implicit m: ClassTag[T]): CanBuildFrom[ImmutableArray[_], T, ImmutableArray[T]] =
+    new CanBuildFrom[ImmutableArray[_], T, ImmutableArray[T]] {
+      def apply(from: ImmutableArray[_]): Builder[T, ImmutableArray[T]] =
+        ArrayBuilder.make[T]()(m) mapResult ImmutableArray.unsafeWrapArray[T]
+      def apply: Builder[T, ImmutableArray[T]] =
+        ArrayBuilder.make[T]()(m) mapResult ImmutableArray.unsafeWrapArray[T]
+    }
+
+  final class ofRef[T <: AnyRef](val unsafeArray: Array[T]) extends ImmutableArray[T] with Serializable {
+    lazy val elemTag = ClassTag[T](unsafeArray.getClass.getComponentType)
+    def length: Int = unsafeArray.length
+    def apply(index: Int): T = unsafeArray(index).asInstanceOf[T]
+    def update(index: Int, elem: T) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofRef[_] => Arrays.equals(unsafeArray.asInstanceOf[Array[AnyRef]], that.unsafeArray.asInstanceOf[Array[AnyRef]])
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofByte(val unsafeArray: Array[Byte]) extends ImmutableArray[Byte] with Serializable {
+    def elemTag = ClassTag.Byte
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Byte = unsafeArray(index)
+    def update(index: Int, elem: Byte) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedBytesHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofByte => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofShort(val unsafeArray: Array[Short]) extends ImmutableArray[Short] with Serializable {
+    def elemTag = ClassTag.Short
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Short = unsafeArray(index)
+    def update(index: Int, elem: Short) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofShort => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofChar(val unsafeArray: Array[Char]) extends ImmutableArray[Char] with Serializable {
+    def elemTag = ClassTag.Char
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Char = unsafeArray(index)
+    def update(index: Int, elem: Char) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofChar => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofInt(val unsafeArray: Array[Int]) extends ImmutableArray[Int] with Serializable {
+    def elemTag = ClassTag.Int
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Int = unsafeArray(index)
+    def update(index: Int, elem: Int) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofInt => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofLong(val unsafeArray: Array[Long]) extends ImmutableArray[Long] with Serializable {
+    def elemTag = ClassTag.Long
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Long = unsafeArray(index)
+    def update(index: Int, elem: Long) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofLong => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofFloat(val unsafeArray: Array[Float]) extends ImmutableArray[Float] with Serializable {
+    def elemTag = ClassTag.Float
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Float = unsafeArray(index)
+    def update(index: Int, elem: Float) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofFloat => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofDouble(val unsafeArray: Array[Double]) extends ImmutableArray[Double] with Serializable {
+    def elemTag = ClassTag.Double
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Double = unsafeArray(index)
+    def update(index: Int, elem: Double) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofDouble => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofBoolean(val unsafeArray: Array[Boolean]) extends ImmutableArray[Boolean] with Serializable {
+    def elemTag = ClassTag.Boolean
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Boolean = unsafeArray(index)
+    def update(index: Int, elem: Boolean) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofBoolean => Arrays.equals(unsafeArray, that.unsafeArray)
+      case _ => super.equals(that)
+    }
+  }
+
+  final class ofUnit(val unsafeArray: Array[Unit]) extends ImmutableArray[Unit] with Serializable {
+    def elemTag = ClassTag.Unit
+    def length: Int = unsafeArray.length
+    def apply(index: Int): Unit = unsafeArray(index)
+    def update(index: Int, elem: Unit) { unsafeArray(index) = elem }
+    override def hashCode = MurmurHash3.wrappedArrayHash(unsafeArray)
+    override def equals(that: Any) = that match {
+      case that: ofUnit => unsafeArray.length == that.unsafeArray.length
+      case _ => super.equals(that)
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+package scala.collection
+
+// Empty dummy package to allow cross-building with Scala 2.12
+package object compat {
+}

src/test/scala/CollectionTest.scala

@@ -0,0 +1,49 @@
+import java.util
+
+import org.junit.Test
+import org.junit.Assert._
+
+import scala.collection.immutable.BitSet
+import scala.collection.compat._
+
+class CollectionTest {
+  @Test
+  def testTo: Unit = {
+    val xs = List(1,2,3)
+    val v = xs.to(Vector)
+    val vT: Vector[Int] = v
+    assertEquals(Vector(1,2,3), v)
+
+    val a = xs.to(Array)
+    val aT: Array[Int] = a
+    assertEquals(Vector(1,2,3), a.toVector)
+
+    val b = xs.to(BitSet) // we can fake a type constructor for the 2 standard BitSet types
+    val bT: BitSet = b
+    assertEquals(BitSet(1,2,3), b)
+
+    val ys = List(1 -> "a", 2 -> "b")
+    val m = ys.to(Map)
+    // Not possible - `to` returns a Col[A] so this is only typed as an Iterable[(Int, String)]
+    //val mT: Map[Int, String] = m
+    assertEquals(Map(1 -> "a", 2 -> "b"), m)
+    assertTrue(m.isInstanceOf[Map[_, _]])
+  }
+
+  @Test
+  def testFrom: Unit = {
+    val xs = List(1,2,3)
+    val v = Vector.from(xs)
+    val vT: Vector[Int] = v
+    assertEquals(Vector(1,2,3), v)
+
+    val b = BitSet.fromSpecific(xs)
+    val bT: BitSet = b
+    assertEquals(BitSet(1,2,3), b)
+
+    val ys = List(1 -> "a", 2 -> "b")
+    val m = Map.from(ys)
+    val mT: Map[Int, String] = m
+    assertEquals(Map(1 -> "a", 2 -> "b"), m)
+  }
+}