Make the breakOut rewrite rule cross compatible (fix #80)

Author: MasseGuillaume

build.sbt

@@ -22,7 +22,7 @@ lazy val compat = crossProject(JSPlatform, JVMPlatform)
   .jvmSettings(scalaModuleSettingsJVM)
   .settings(
     name := "scala-collection-compat",
-    version := "0.1-SNAPSHOT",
+    version := "0.2.0-SNAPSHOT",
     scalacOptions ++= Seq("-feature", "-language:higherKinds", "-language:implicitConversions"),
     unmanagedSourceDirectories in Compile += {
       val sharedSourceDir = baseDirectory.value.getParentFile / "src/main"
@@ -52,6 +52,7 @@ lazy val scalafixRules = project
   .in(file("scalafix/rules"))
   .settings(
     organization := (organization in compatJVM).value,
+    version := (version  in compatJVM).value,
     name := "scala-collection-migrations",
     scalaVersion := scalafixScala212,
     libraryDependencies += "ch.epfl.scala" %% "scalafix-core" % scalafixVersion

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

@@ -58,6 +58,7 @@ package object compat {
     def sameElements[B >: A](that: IterableOnce[B]): Boolean = {
       self.sameElements(that.iterator)
     }
+    def concat[B >: A](that: IterableOnce[B]): IterableOnce[B] = self ++ that
   }
 
   implicit class TraversableOnceExtensionMethods[A](private val self: TraversableOnce[A]) extends AnyVal {

compat/src/test/scala/test/scala/collection/Playground.scala

@@ -0,0 +1,12 @@
+package test.scala.collection
+
+import org.junit.Test
+import org.junit.Assert._
+import scala.collection.compat._
+
+class Playground {
+  @Test
+  def t(): Unit = {
+
+  }
+}

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.NewCollections"
+rule = "scala:fix.CrossCompat"
  */
 package fix
 
@@ -13,13 +13,14 @@ object BreakoutSrc {
   xs.map(_ + 1)(breakOut): Set[Int]
   xs.reverseMap(_ + 1)(breakOut): Set[Int]
   xs.scanLeft(0)((a, b) => a + b)(breakOut): Set[Int]
-  xs.union(xs)(breakOut): Set[Int]
   xs.updated(0, 1)(breakOut): Set[Int]
-  xs.zip(xs)(breakOut): Map[Int, Int]
-  xs.zipAll(xs, 0, 0)(breakOut): Array[(Int, Int)]
 
   (xs ++ xs)(breakOut): Set[Int]
   (1 +: xs)(breakOut): Set[Int]
   (xs :+ 1)(breakOut): Set[Int]
   (xs ++: xs)(breakOut): Set[Int]
+
+  xs.union(xs)(breakOut): Set[Int]
+  xs.zip(xs)(breakOut): Map[Int, Int]
+  xs.zipAll(xs, 0, 0)(breakOut): Array[(Int, Int)]
 }

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

@@ -0,0 +1,8 @@
+/*
+rule = "scala:fix.CrossCompat"
+ */
+package fix
+
+object Playground {
+
+}

scalafix/output212/src/main/scala/fix/BreakoutSrc.scala

@@ -0,0 +1,27 @@
+
+
+
+package fix
+
+import scala.collection.compat._
+
+object BreakoutSrc {
+  val xs = List(1, 2, 3)
+
+  xs.iterator.collect{ case x => x }.to(scala.collection.immutable.Set): Set[Int]
+  xs.iterator.flatMap(x => List(x)).to(scala.collection.SortedSet): collection.SortedSet[Int]
+  xs.iterator.map(_ + 1).to(scala.collection.immutable.Set): Set[Int]
+  xs.reverseIterator.map(_ + 1).to(scala.collection.immutable.Set): Set[Int]
+  xs.iterator.scanLeft(0)((a, b) => a + b).to(scala.collection.immutable.Set): Set[Int]
+  xs.view.updated(0, 1).to(scala.collection.immutable.Set): Set[Int]
+
+  (xs.iterator ++ xs).to(scala.collection.immutable.Set): Set[Int]
+  (1 +: xs.view).to(scala.collection.immutable.Set): Set[Int]
+  (xs.view :+ 1).to(scala.collection.immutable.Set): Set[Int]
+  (xs ++: xs.view).to(scala.collection.immutable.Set): Set[Int]
+
+  xs.iterator.concat(xs).to(scala.collection.immutable.Set): Set[Int]
+  xs.iterator.zip(xs.iterator).toMap: Map[Int, Int]
+  xs.iterator.zipAll(xs.iterator, 0, 0).to(scala.Array): Array[(Int, Int)]
+}
+

scalafix/output212/src/main/scala/fix/Playground.scala

@@ -0,0 +1,8 @@
+
+
+
+package fix
+
+object Playground {
+
+}

scalafix/output213/src/main/scala/fix/BreakoutSrc.scala

@@ -21,60 +21,6 @@ case class NewCollections(index: SemanticdbIndex)
   val retainMap = normalized("_root_.scala.collection.mutable.MapLike.retain.")
   val retainSet = normalized("_root_.scala.collection.mutable.SetLike.retain.")
 
-  object Breakout {
-    implicit class RichSymbol(val symbol: Symbol) {
-      def exact(tree: Tree)(implicit index: SemanticdbIndex): Boolean =
-        index.symbol(tree).fold(false)(_ == symbol)
-    }
-
-    val breakOut = SymbolMatcher.exact(Symbol("_root_.scala.collection.package.breakOut(Lscala/collection/generic/CanBuildFrom;)Lscala/collection/generic/CanBuildFrom;."))
-
-    // infix operators
-    val `List ++`             = Symbol("_root_.scala.collection.immutable.List#`++`(Lscala/collection/GenTraversableOnce;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `List +:`             = Symbol("_root_.scala.collection.immutable.List#`+:`(Ljava/lang/Object;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `SeqLike :+`          = Symbol("_root_.scala.collection.SeqLike#`:+`(Ljava/lang/Object;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `TraversableLike ++:` = Symbol("_root_.scala.collection.TraversableLike#`++:`(Lscala/collection/Traversable;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-
-    val operatorsIteratorSymbols = List(`List ++`)
-    val operatorsViewSymbols     = List(`List +:`, `SeqLike :+`, `TraversableLike ++:`)
-    val operatorsSymbols         = operatorsViewSymbols ++ operatorsIteratorSymbols
-
-    val operatorsIterator = SymbolMatcher.exact(operatorsIteratorSymbols: _*)
-    val operatorsView     = SymbolMatcher.exact(operatorsViewSymbols: _*)
-    val operators         = SymbolMatcher.exact(operatorsSymbols: _*)
-
-    // select
-    val `List.collect`        = Symbol("_root_.scala.collection.immutable.List#collect(Lscala/PartialFunction;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `List.flatMap`        = Symbol("_root_.scala.collection.immutable.List#flatMap(Lscala/Function1;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `List.map`            = Symbol("_root_.scala.collection.immutable.List#map(Lscala/Function1;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `IterableLike.zip`    = Symbol("_root_.scala.collection.IterableLike#zip(Lscala/collection/GenIterable;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `IterableLike.zipAll` = Symbol("_root_.scala.collection.IterableLike#zipAll(Lscala/collection/GenIterable;Ljava/lang/Object;Ljava/lang/Object;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `SeqLike.union`       = Symbol("_root_.scala.collection.SeqLike#union(Lscala/collection/GenSeq;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `SeqLike.updated`     = Symbol("_root_.scala.collection.SeqLike#updated(ILjava/lang/Object;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-    val `SeqLike.reverseMap`  = Symbol("_root_.scala.collection.SeqLike#reverseMap(Lscala/Function1;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
-
-    val functionsIteratorSymbols        = List(`List.collect`, `List.flatMap`, `List.map`, `IterableLike.zip`, `IterableLike.zipAll`, `SeqLike.union`)
-    val functionsViewSymbols            = List(`SeqLike.updated`)
-    val functionsReverseIteratorSymbols = List(`SeqLike.reverseMap`)
-    val functionsSymbols                = functionsIteratorSymbols ++ functionsViewSymbols ++ functionsReverseIteratorSymbols
-
-    val functionsIterator        = SymbolMatcher.exact(functionsIteratorSymbols: _*)
-    val functionsReverseIterator = SymbolMatcher.exact(functionsReverseIteratorSymbols: _*)
-    val functionsView            = SymbolMatcher.exact(functionsViewSymbols: _*)
-    val functions                = SymbolMatcher.exact(functionsSymbols: _*)
-
-    // special select
-
-    // iterator
-    val `TraversableLike.scanLeft` = SymbolMatcher.exact(Symbol("_root_.scala.collection.TraversableLike#scanLeft(Ljava/lang/Object;Lscala/Function2;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;."))
-
-    def isLeftAssociative(tree: Tree): Boolean =
-      tree match {
-        case Term.Name(value) => value.last != ':'
-        case _ => false
-      }
-  }
-
   // == Rules ==
 
   def replaceSymbols(ctx: RuleCtx): Patch = {
@@ -146,66 +92,13 @@ case class NewCollections(index: SemanticdbIndex)
     }.asPatch
   }
 
-  def replaceBreakout(ctx: RuleCtx): Patch = {
-    import Breakout._
-
-    def fixIt(intermediate: String, lhs: Term, ap: Term, breakout: Tree): Patch = {
-      ctx.addRight(lhs, "." + intermediate) +
-      ctx.addRight(ap, ".to") +
-      ctx.replaceTree(breakout, "implicitly")
-    }
-
-    ctx.tree.collect {
-      case i: Importee if breakOut.matches(i) =>
-        ctx.removeImportee(i)
-
-      case Term.Apply(ap @ Term.ApplyInfix(lhs, operators(op), _, List(rhs)), List(breakOut(bo))) =>
-        val subject =
-          if(isLeftAssociative(op)) lhs
-          else rhs
-
-        val intermediate =
-          op match {
-            case operatorsIterator(_) => "iterator"
-            case operatorsView(_)     => "view"
-            // since operators(op) matches iterator and view
-            case _                    => throw new Exception("impossible")
-          }
-
-        fixIt(intermediate, subject, ap, bo)
-
-      case Term.Apply(ap @ Term.Apply(Term.Select(lhs, functions(op)), _), List(breakOut(bo))) =>
-        val intermediate =
-          op match {
-            case functionsIterator(_)        => "iterator"
-            case functionsView(_)            => "view"
-            case functionsReverseIterator(_) => "reverseIterator"
-            // since functions(op) matches iterator, view and reverseIterator
-            case _                           => throw new Exception("impossible")
-          }
-
-        val replaceUnion =
-          if (`SeqLike.union`.exact(op)) ctx.replaceTree(op, "concat")
-          else Patch.empty
-
-        val isReversed = `SeqLike.reverseMap`.exact(op)
-        val replaceReverseMap =
-          if (isReversed) ctx.replaceTree(op, "map")
-          else Patch.empty
-
-        fixIt(intermediate, lhs, ap, bo) + replaceUnion + replaceReverseMap
-
-      case Term.Apply(ap @ Term.Apply(Term.Apply(Term.Select(lhs, `TraversableLike.scanLeft`(op)), _), _), List(breakOut(bo))) =>
-        fixIt("iterator", lhs, ap, bo)
-    }.asPatch
-  }
+  
 
   override def fix(ctx: RuleCtx): Patch = {
     super.fix(ctx) +
       replaceSymbols(ctx) +
       replaceTupleZipped(ctx) +
       replaceMutableMap(ctx) +
-      replaceMutableSet(ctx) +
-      replaceBreakout(ctx)
+      replaceMutableSet(ctx)
   }
 }