Merge pull request #24 from lrytz/iterator

ImmutableArray -> ArraySeq, iterator() -> iterator

Author: lrytz

.travis.yml

@@ -3,7 +3,7 @@ language: scala
 scala:
   - 2.11.12
   - 2.12.6
-  - 2.13.0-pre-abf21b9
+  - 2.13.0-pre-a002630
 jdk:
   - oraclejdk8
 env:
@@ -21,9 +21,9 @@ env:
 
 matrix:
   exclude:
-    - scala: 2.13.0-pre-abf21b9
+    - scala: 2.13.0-pre-a002630
       env: SCALAJS_VERSION=0.6.22
-    - scala: 2.13.0-pre-abf21b9
+    - scala: 2.13.0-pre-a002630
       env: SCALAJS_VERSION=1.0.0-M3
   include:
     - scala: 2.12.6

CONTRIBUTING.md

@@ -20,7 +20,7 @@ the strawman:
 
 ~~~ diff
 - xs.toIterator
-+ xs.iterator()
++ xs.iterator
 ~~~
 
 ### Add a missing test case
@@ -45,7 +45,7 @@ class toIteratorVsIterator(xs: Iterable[Int]) {
 import strawman.collection.Iterable
 
 class toIteratorVsIterator(xs: Iterable[Int]) {
-  xs.iterator()
+  xs.iterator
 }
 ~~~
 

build.sbt

@@ -3,7 +3,7 @@ import ScalaModulePlugin._
 
 inThisBuild(Seq(
   resolvers += "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-integration/",
-  crossScalaVersions := Seq("2.12.6", "2.13.0-pre-abf21b9", "2.11.12")
+  crossScalaVersions := Seq("2.12.6", "2.13.0-pre-a002630", "2.11.12")
 ))
 
 lazy val `scala-collection-compat` = crossProject(JSPlatform, JVMPlatform)

scalafix/build.sbt

@@ -23,7 +23,7 @@ lazy val input = project
 lazy val output = project
   .settings(
     resolvers += "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-integration/",
-    scalaVersion := "2.13.0-pre-abf21b9"
+    scalaVersion := "2.13.0-pre-a002630"
   )
 
 lazy val tests = project

scalafix/output/src/main/scala/fix/TraversableSrc.scala

@@ -4,7 +4,7 @@ object TraversableSrc {
   def foo(xs: Iterable[(Int, String)], ys: List[Int]): Unit = {
     xs.to(List)
     xs.to(Set)
-    xs.iterator()
-    ys.iterator()
+    xs.iterator
+    ys.iterator
   }
 }

scalafix/rules/src/main/scala/fix/Scalacollectioncompat_NewCollections.scala

@@ -23,7 +23,6 @@ case class Scalacollectioncompat_NewCollections(index: SemanticdbIndex)
     Symbol("_root_.scala.collection.TraversableLike.to.")
   )
   val iterator = SymbolMatcher.normalized(
-    Symbol("_root_.scala.collection.LinearSeqLike.iterator."),
     Symbol("_root_.scala.collection.TraversableLike.toIterator.")
   )
   val tupleZipped = SymbolMatcher.normalized(
@@ -34,7 +33,7 @@ case class Scalacollectioncompat_NewCollections(index: SemanticdbIndex)
   def replaceToList(ctx: RuleCtx) =
     ctx.tree.collect {
       case iterator(t: Name) =>
-        ctx.replaceTree(t, "iterator()")
+        ctx.replaceTree(t, "iterator")
       case toTpe(n: Name) =>
         (for {
           name <- n.tokens.lastOption

src/main/scala-2.11_2.12/scala/collection/immutable/ImmutableArray.scala renamed to src/main/scala-2.11_2.12/scala/collection/immutable/ArraySeq.scala

@@ -16,19 +16,19 @@ import java.util.Arrays
   *
   * Supports efficient indexed access and has a small memory footprint.
   *
-  *  @define Coll `ImmutableArray`
+  *  @define Coll `ArraySeq`
   *  @define coll wrapped array
   *  @define orderDependent
   *  @define orderDependentFold
   *  @define mayNotTerminateInf
   *  @define willNotTerminateInf
   */
-abstract class ImmutableArray[+T]
+abstract class ArraySeq[+T]
   extends AbstractSeq[T]
     with IndexedSeq[T]
 {
 
-  override protected[this] def thisCollection: ImmutableArray[T] = this
+  override protected[this] def thisCollection: ArraySeq[T] = this
 
   /** The tag of the element type */
   protected[this] def elemTag: ClassTag[T]
@@ -45,31 +45,31 @@ abstract class ImmutableArray[+T]
   private def elementClass: Class[_] =
     unsafeArray.getClass.getComponentType
 
-  override def stringPrefix = "ImmutableArray"
+  override def stringPrefix = "ArraySeq"
 
   /** Clones this object, including the underlying Array. */
-  override def clone(): ImmutableArray[T] = ImmutableArray unsafeWrapArray unsafeArray.clone()
+  override def clone(): ArraySeq[T] = ArraySeq 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))
+  override protected[this] def newBuilder: Builder[T, ArraySeq[T]] =
+    new WrappedArrayBuilder[T](elemTag).mapResult(w => ArraySeq.unsafeWrapArray(w.array))
 
 }
 
-/** A companion object used to create instances of `ImmutableArray`.
+/** A companion object used to create instances of `ArraySeq`.
   */
-object ImmutableArray {
+object ArraySeq {
   // 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]]
+  private val EmptyArraySeq  = new ofRef[AnyRef](new Array[AnyRef](0))
+  def empty[T <: AnyRef]: ArraySeq[T] = EmptyArraySeq.asInstanceOf[ArraySeq[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
+  // empty.  This may be unnecessary (if ArraySeq 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 {
+  def unsafeWrapArray[T](x: AnyRef): ArraySeq[T] = (x match {
     case null              => null
     case x: Array[AnyRef]  => new ofRef[AnyRef](x)
     case x: Array[Int]     => new ofInt(x)
@@ -81,17 +81,17 @@ object ImmutableArray {
     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]
+  }).asInstanceOf[ArraySeq[T]]
+
+  implicit def canBuildFrom[T](implicit m: ClassTag[T]): CanBuildFrom[ArraySeq[_], T, ArraySeq[T]] =
+    new CanBuildFrom[ArraySeq[_], T, ArraySeq[T]] {
+      def apply(from: ArraySeq[_]): Builder[T, ArraySeq[T]] =
+        ArrayBuilder.make[T]()(m) mapResult ArraySeq.unsafeWrapArray[T]
+      def apply: Builder[T, ArraySeq[T]] =
+        ArrayBuilder.make[T]()(m) mapResult ArraySeq.unsafeWrapArray[T]
     }
 
-  final class ofRef[T <: AnyRef](val unsafeArray: Array[T]) extends ImmutableArray[T] with Serializable {
+  final class ofRef[T <: AnyRef](val unsafeArray: Array[T]) extends ArraySeq[T] with Serializable {
     lazy val elemTag = ClassTag[T](unsafeArray.getClass.getComponentType)
     def length: Int = unsafeArray.length
     def apply(index: Int): T = unsafeArray(index)
@@ -103,7 +103,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofByte(val unsafeArray: Array[Byte]) extends ImmutableArray[Byte] with Serializable {
+  final class ofByte(val unsafeArray: Array[Byte]) extends ArraySeq[Byte] with Serializable {
     def elemTag = ClassTag.Byte
     def length: Int = unsafeArray.length
     def apply(index: Int): Byte = unsafeArray(index)
@@ -115,7 +115,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofShort(val unsafeArray: Array[Short]) extends ImmutableArray[Short] with Serializable {
+  final class ofShort(val unsafeArray: Array[Short]) extends ArraySeq[Short] with Serializable {
     def elemTag = ClassTag.Short
     def length: Int = unsafeArray.length
     def apply(index: Int): Short = unsafeArray(index)
@@ -127,7 +127,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofChar(val unsafeArray: Array[Char]) extends ImmutableArray[Char] with Serializable {
+  final class ofChar(val unsafeArray: Array[Char]) extends ArraySeq[Char] with Serializable {
     def elemTag = ClassTag.Char
     def length: Int = unsafeArray.length
     def apply(index: Int): Char = unsafeArray(index)
@@ -139,7 +139,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofInt(val unsafeArray: Array[Int]) extends ImmutableArray[Int] with Serializable {
+  final class ofInt(val unsafeArray: Array[Int]) extends ArraySeq[Int] with Serializable {
     def elemTag = ClassTag.Int
     def length: Int = unsafeArray.length
     def apply(index: Int): Int = unsafeArray(index)
@@ -151,7 +151,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofLong(val unsafeArray: Array[Long]) extends ImmutableArray[Long] with Serializable {
+  final class ofLong(val unsafeArray: Array[Long]) extends ArraySeq[Long] with Serializable {
     def elemTag = ClassTag.Long
     def length: Int = unsafeArray.length
     def apply(index: Int): Long = unsafeArray(index)
@@ -163,7 +163,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofFloat(val unsafeArray: Array[Float]) extends ImmutableArray[Float] with Serializable {
+  final class ofFloat(val unsafeArray: Array[Float]) extends ArraySeq[Float] with Serializable {
     def elemTag = ClassTag.Float
     def length: Int = unsafeArray.length
     def apply(index: Int): Float = unsafeArray(index)
@@ -175,7 +175,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofDouble(val unsafeArray: Array[Double]) extends ImmutableArray[Double] with Serializable {
+  final class ofDouble(val unsafeArray: Array[Double]) extends ArraySeq[Double] with Serializable {
     def elemTag = ClassTag.Double
     def length: Int = unsafeArray.length
     def apply(index: Int): Double = unsafeArray(index)
@@ -187,7 +187,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofBoolean(val unsafeArray: Array[Boolean]) extends ImmutableArray[Boolean] with Serializable {
+  final class ofBoolean(val unsafeArray: Array[Boolean]) extends ArraySeq[Boolean] with Serializable {
     def elemTag = ClassTag.Boolean
     def length: Int = unsafeArray.length
     def apply(index: Int): Boolean = unsafeArray(index)
@@ -199,7 +199,7 @@ object ImmutableArray {
     }
   }
 
-  final class ofUnit(val unsafeArray: Array[Unit]) extends ImmutableArray[Unit] with Serializable {
+  final class ofUnit(val unsafeArray: Array[Unit]) extends ArraySeq[Unit] with Serializable {
     def elemTag = ClassTag.Unit
     def length: Int = unsafeArray.length
     def apply(index: Int): Unit = unsafeArray(index)

src/test/scala/test/scala/collection/ImmutableArrayTest.scala renamed to src/test/scala/test/scala/collection/ArraySeqTest.scala

@@ -2,15 +2,15 @@ package test.scala.collection
 
 import org.junit.{Assert, Test}
 
-import scala.collection.immutable.ImmutableArray
+import scala.collection.immutable.ArraySeq
 
-// The unmodified ImmutableArrayTest from collection-strawman
-class ImmutableArrayTest {
+// The unmodified ArraySeqTest from collection-strawman
+class ArraySeqTest {
   @Test
   def slice(): Unit = {
 
-    implicit def array2ImmutableArray[T](array: Array[T]): ImmutableArray[T] =
-      ImmutableArray.unsafeWrapArray(array)
+    implicit def array2ArraySeq[T](array: Array[T]): ArraySeq[T] =
+      ArraySeq.unsafeWrapArray(array)
 
     val booleanArray = Array(true, false, true, false)
     check(booleanArray, Array(true, false), Array(false, true))
@@ -44,17 +44,17 @@ class ImmutableArrayTest {
     Assert.assertEquals(unit1, unit2)
     // unitArray is actually an instance of Immutable[BoxedUnit], the check to which is actually checked slice
     // implementation of ofRef
-    val unitArray: ImmutableArray[Unit] = Array(unit1, unit2, unit1, unit2)
+    val unitArray: ArraySeq[Unit] = Array(unit1, unit2, unit1, unit2)
     check(unitArray, Array(unit1, unit1), Array(unit1, unit1))
   }
 
-  private def check[T](array: ImmutableArray[T], expectedSliceResult1: ImmutableArray[T], expectedSliceResult2: ImmutableArray[T]) {
+  private def check[T](array: ArraySeq[T], expectedSliceResult1: ArraySeq[T], expectedSliceResult2: ArraySeq[T]) {
     Assert.assertEquals(array, array.slice(-1, 4))
     Assert.assertEquals(array, array.slice(0, 5))
     Assert.assertEquals(array, array.slice(-1, 5))
     Assert.assertEquals(expectedSliceResult1, array.slice(0, 2))
     Assert.assertEquals(expectedSliceResult2, array.slice(1, 3))
-    Assert.assertEquals(ImmutableArray.empty[Nothing], array.slice(1, 1))
-    Assert.assertEquals(ImmutableArray.empty[Nothing], array.slice(2, 1))
+    Assert.assertEquals(ArraySeq.empty[Nothing], array.slice(1, 1))
+    Assert.assertEquals(ArraySeq.empty[Nothing], array.slice(2, 1))
   }
 }