Move migration rules here

CONTRIBUTING.md

@@ -0,0 +1,77 @@
+# Contributing
+
+## Build
+
+### Sbt Projects
+
+- `scala-collection-compat` project (in the root directory): implementation of the compatibility library ;
+- In directory `scalafix/` there is an independent build containing the implementation of the migration tool.
+
+## Migration tool
+
+Several levels of contribution are possible!
+
+### Report a missing case
+
+Create an issue tagged with the
+[migration](https://github.com/scala/collection-strawman/labels/migration) label.
+Embrace `diff`s to describe differences between the standard collections and
+the strawman:
+
+~~~ diff
+- xs.toIterator
++ xs.iterator()
+~~~
+
+### Add a missing test case
+
+Even better, instead of providing a diff, you can directly add it as a test case!
+
+1. Fork this repository and create a separate branch;
+
+2. Add a file in the `scalafix/input/src/main/scala/fix/` directory with code
+   that uses the standard collections:
+
+~~~ scala
+class toIteratorVsIterator(xs: Iterable[Int]) {
+  xs.toIterator
+}
+~~~
+
+3. Add a corresponding file in the `scalafix/output/src/main/scala/fix/` directory
+   with the same code but using the strawman:
+
+~~~ scala
+import strawman.collection.Iterable
+
+class toIteratorVsIterator(xs: Iterable[Int]) {
+  xs.iterator()
+}
+~~~
+
+4. Check that your code example compiles
+    - run sbt from the `scalafix/` directory
+      and then run the following tasks `; input/compile ; output/compile`;
+
+5. Commit your changes, push your branch to your fork and create a pull request.
+
+Then maybe someone will take over and implement your use case… or maybe you will
+(see next section)!
+
+### Implement a missing case
+
+Even better, complete the migration tool implementation to support the missing case!
+
+After you have added the missing case (see previous section), run the following
+sbt task (with sbt started from the `scalafix/` directory) to run the
+migration tool on the input files and check whether the result matches the
+expected output files:
+
+~~~
+> tests/test
+~~~
+
+Fix the implementation of the rule (in the
+`rules/src/main/scala/fix/Scalacollectioncompat_v0.scala` file) until the
+tests are green. You can find more help about the scalafix API in its
+[documentation](https://scalacenter.github.io/scalafix/docs/rule-authors/setup).

README.md

@@ -1,7 +1,9 @@
 [![Build Status](https://travis-ci.org/scala/scala-collection-compat.svg?branch=master)](https://travis-ci.org/scala/scala-collection-compat)
 
-Scala 2.13 Collection Compatibility Library
-===========================================
+Scala 2.13 Collection Compatibility Library And Migration Tool
+==============================================================
+
+## 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
@@ -24,3 +26,25 @@ This project can be cross-built on 2.13 (with new collections) and 2.12. The 2.1
 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.
+
+## Migration Tool
+
+A tool is being developed to automatically migrate code that uses the standard
+collection to use the strawman.
+
+To use it, add the [scalafix](https://scalacenter.github.io/scalafix/) sbt plugin
+to your build, as explained in
+[its documentation](https://scalacenter.github.io/scalafix/#Installation).
+
+The migration tool is not exhaustive and we will continue to improve
+it over time. If you encounter a use case that’s not supported, please
+report it as described in the
+[contributing documentation](CONTRIBUTING.md#migration-tool).
+
+### Migrating a 2.12 code base to 2.13
+
+Run the following sbt task on your project:
+
+~~~
+> scalafix github:scala/scala-collection-compat/v0
+~~~

scalafix/build.sbt

@@ -0,0 +1,43 @@
+def scalafixVersion = _root_.scalafix.Versions.version
+inScope(Global)(
+  List(
+    scalaVersion := _root_.scalafix.Versions.scala212
+  )
+)
+
+lazy val root = project
+  .in(file("."))
+  .aggregate(
+    rules, input, output, tests
+  )
+
+lazy val rules = project.settings(
+  libraryDependencies += "ch.epfl.scala" %% "scalafix-core" % scalafixVersion
+)
+
+lazy val input = project
+  .settings(
+    scalafixSourceroot := sourceDirectory.in(Compile).value
+  )
+
+lazy val output = project
+  .settings(
+    resolvers += "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-integration/",
+    scalaVersion := "2.13.0-M4-pre-20d3c21"
+  )
+
+lazy val tests = project
+  .settings(
+    libraryDependencies += "ch.epfl.scala" % "scalafix-testkit" % scalafixVersion % Test cross CrossVersion.full,
+    buildInfoPackage := "fix",
+    buildInfoKeys := Seq[BuildInfoKey](
+      "inputSourceroot" ->
+        sourceDirectory.in(input, Compile).value,
+      "outputSourceroot" ->
+        sourceDirectory.in(output, Compile).value,
+      "inputClassdirectory" ->
+        classDirectory.in(input, Compile).value
+    )
+  )
+  .dependsOn(input, rules)
+  .enablePlugins(BuildInfoPlugin)

scalafix/input/src/main/scala/fix/Collectionstrawman_v0_Stream.scala

@@ -0,0 +1,14 @@
+/*
+rule = "scala:fix.Collectionstrawman_v0"
+ */
+package fix
+
+object Collectionstrawman_v0_Stream {
+  val s = Stream(1, 2, 3)
+  s.append(List(4, 5, 6))
+  1 #:: 2 #:: 3 #:: Stream.Empty
+  val isEmpty: Stream[_] => Boolean = {
+    case Stream.Empty => true
+    case x #:: xs     => false
+  }
+}

scalafix/input/src/main/scala/fix/Collectionstrawman_v0_Traversable.scala

@@ -0,0 +1,13 @@
+/*
+rule = "scala:fix.Collectionstrawman_v0"
+ */
+package fix
+
+object Collectionstrawman_v0_Traversable {
+  def foo(xs: Traversable[(Int, String)], ys: List[Int]): Unit = {
+    xs.to[List]
+    xs.to[Set]
+    xs.toIterator
+    ys.iterator
+  }
+}

scalafix/input/src/main/scala/fix/Collectionstrawman_v0_TupleNZipped.scala

@@ -0,0 +1,36 @@
+/*
+rule = "scala:fix.Collectionstrawman_v0"
+ */
+package fix
+
+import scala.language.postfixOps
+object Collectionstrawman_v0_Tuple2Zipped {
+  def zipped(xs: List[Int], ys: List[Int]): Unit = {
+    (xs, ys).zipped
+    (xs,ys).zipped
+    ((xs, ys) zipped)
+    (((xs)    ,    (ys)).zipped)
+    (xs, // foo
+      ys).zipped
+    /* a */(/* b */ xs /* c */, /* d */ ys /* e */)/* f */./* g */zipped/* h */
+    (coll(1), coll(2)).zipped
+    (List(1, 2, 3), Stream.from(1)).zipped
+  }
+  def coll(x: Int): List[Int] = ???
+}
+
+object Collectionstrawman_v0_Tuple3Zipped {
+  def zipped(xs: List[Int], ys: List[Int], zs: List[Int]): Unit = {
+    (xs, ys, zs).zipped
+    (xs,ys,zs).zipped
+    ((xs, ys, zs) zipped)
+    (((xs)    ,    (ys)    ,    (zs)).zipped)
+    (xs, // foo
+      ys, // bar
+      zs).zipped
+    /* a */(/* b */ xs /* c */, /* d */ ys /* e */, /* f */ zs /* g */)/* h */./* i */zipped/* j */
+    (coll(1), coll(2), coll(3)).zipped
+    (List(1, 2, 3), Set(1, 2, 3), Stream.from(1)).zipped
+  }
+  def coll(x: Int): List[Int] = ???
+}

scalafix/input/src/main/scala/fix/Collectionstrawman_v0_copyToBuffer.scala

@@ -0,0 +1,13 @@
+/*
+rule = "scala:fix.Collectionstrawman_v0"
+ */
+package fix
+
+import scala.collection.mutable
+
+class Collectionstrawman_v0_copyToBuffer(xs: List[Int], b: mutable.Buffer[Int]) {
+
+  xs.copyToBuffer(b)
+  (xs ++ xs).copyToBuffer(b)
+
+}

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

@@ -0,0 +1,11 @@
+package fix
+
+object Collectionstrawman_v0_Stream {
+  val s = LazyList(1, 2, 3)
+  s.lazyAppendAll(List(4, 5, 6))
+  1 #:: 2 #:: 3 #:: LazyList.Empty
+  val isEmpty: LazyList[_] => Boolean = {
+    case LazyList.Empty => true
+    case x #:: xs     => false
+  }
+}

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

@@ -0,0 +1,10 @@
+package fix
+
+object Collectionstrawman_v0_Traversable {
+  def foo(xs: Iterable[(Int, String)], ys: List[Int]): Unit = {
+    xs.to(List)
+    xs.to(Set)
+    xs.iterator()
+    ys.iterator()
+  }
+}

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

@@ -0,0 +1,33 @@
+package fix
+
+import scala.language.postfixOps
+object Collectionstrawman_v0_Tuple2Zipped {
+  def zipped(xs: List[Int], ys: List[Int]): Unit = {
+    xs.lazyZip(ys)
+    xs.lazyZip(ys)
+    (xs.lazyZip(ys) )
+    ((xs).lazyZip((ys)))
+    xs.lazyZip(// foo
+      ys)
+    /* a *//* b */ xs /* c */.lazyZip(/* d */ ys /* e */)/* f *//* g *//* h */
+    coll(1).lazyZip(coll(2))
+    List(1, 2, 3).lazyZip(LazyList.from(1))
+  }
+  def coll(x: Int): List[Int] = ???
+}
+
+object Collectionstrawman_v0_Tuple3Zipped {
+  def zipped(xs: List[Int], ys: List[Int], zs: List[Int]): Unit = {
+    xs.lazyZip(ys).lazyZip(zs)
+    xs.lazyZip(ys).lazyZip(zs)
+    (xs.lazyZip(ys).lazyZip(zs) )
+    ((xs).lazyZip((ys)).lazyZip((zs)))
+    xs.lazyZip(// foo
+      ys).lazyZip(// bar
+      zs)
+    /* a *//* b */ xs /* c */.lazyZip(/* d */ ys /* e */).lazyZip(/* f */ zs /* g */)/* h *//* i *//* j */
+    coll(1).lazyZip(coll(2)).lazyZip(coll(3))
+    List(1, 2, 3).lazyZip(Set(1, 2, 3)).lazyZip(LazyList.from(1))
+  }
+  def coll(x: Int): List[Int] = ???
+}

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

@@ -0,0 +1,10 @@
+package fix
+
+import scala.collection.mutable
+
+class Collectionstrawman_v0_copyToBuffer(xs: List[Int], b: mutable.Buffer[Int]) {
+
+  b ++= xs
+  b ++= xs ++ xs
+
+}

scalafix/project/build.properties

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

scalafix/project/plugins.sbt

@@ -0,0 +1,3 @@
+addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.5.7")
+addSbtPlugin("io.get-coursier" % "sbt-coursier" % "1.0.0")
+addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.6.1")