Split rules that can be used to cross compile

Author: MasseGuillaume

scalafix/build.sbt

@@ -8,7 +8,7 @@ inScope(Global)(
 lazy val root = project
   .in(file("."))
   .aggregate(
-    rules, input, output, tests
+    rules, input, output212, output213, output213Failure, tests
   )
 
 lazy val rules = project.settings(
@@ -20,13 +20,15 @@ lazy val input = project
     scalafixSourceroot := sourceDirectory.in(Compile).value
   )
 
-lazy val output = project
+lazy val output212 = project
+
+lazy val output213 = project
   .settings(
     resolvers += "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-integration/",
     scalaVersion := "2.13.0-M4"
   )
 
-lazy val outputFailure = project.in(file("output-failure"))
+lazy val output213Failure = project.in(file("output213-failure"))
   .settings(
     resolvers += "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-integration/",
     scalaVersion := "2.13.0-M4"
@@ -39,14 +41,19 @@ lazy val tests = project
     buildInfoKeys := Seq[BuildInfoKey](
       "inputSourceroot" ->
         sourceDirectory.in(input, Compile).value,
-      "outputSourceroot" ->
-        sourceDirectory.in(output, Compile).value,
-      "outputFailureSourceroot" ->
-        sourceDirectory.in(outputFailure, Compile).value,
+      "output212Sourceroot" ->
+        sourceDirectory.in(output212, Compile).value,
+      "output213Sourceroot" ->
+        sourceDirectory.in(output213, Compile).value,
+      "output213FailureSourceroot" ->
+        sourceDirectory.in(output213Failure, Compile).value,
       "inputClassdirectory" ->
         classDirectory.in(input, Compile).value
     ),
-    test in Test := (test in Test).dependsOn(compile in (output, Compile)).value
+    test in Test := (test in Test).dependsOn(
+      compile in (output212, Compile),
+      compile in (output213, Compile)
+    ).value
   )
   .dependsOn(input, rules)
   .enablePlugins(BuildInfoPlugin)

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable213"
  */
 package fix
 

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable213"
  */
 package fix
 

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

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

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable212"
  */
 package fix
 

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

@@ -1,8 +1,8 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable213"
  */
 package fix
 
 class IterableSrc(it: Iterable[Int]) {
   it.sameElements(it)
-}
+}

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable212"
  */
 package fix
 

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable212"
  */
 package fix
 
@@ -10,4 +10,4 @@ class MutSetMapSrc(map: mutable.Map[Int, Int], set: mutable.Set[Int]) {
   map + (2 -> 3)
   (set + 2).size
   map.updated(1, 3)
-}
+}

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable213"
  */
 package fix
 
@@ -9,4 +9,4 @@ class MethodRenames(xs: Map[Int, Int], ys: Set[Int]) {
   xs.retain((_, _) => true)
   xs.retain{case (x, y) => true}
   ys.retain(_ => true)
-}
+}

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable212"
  */
 package fix
 

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable212"
  */
 package fix
 

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable213"
  */
 package fix
 

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

@@ -1,5 +1,5 @@
 /*
-rule = "scala:fix.Stable"
+rule = "scala:fix.Stable213"
  */
 package fix
 
@@ -33,4 +33,4 @@ object Collectionstrawman_v0_Tuple3Zipped {
     (List(1, 2, 3), Set(1, 2, 3), Array(1)).zipped
   }
   def coll(x: Int): List[Int] = ???
-}
+}

scalafix/output/src/main/scala/fix/CopyToBufferSrc.scala renamed to scalafix/output212/src/main/scala/fix/CopyToBufferSrc.scala

@@ -6,8 +6,6 @@ package fix
 import scala.collection.mutable
 
 class CopyToBufferSrc(xs: List[Int], b: mutable.Buffer[Int]) {
-
   b ++= xs
   b ++= xs ++ xs
-
 }

scalafix/output/src/main/scala/fix/ExperimentalSrc.scala renamed to scalafix/output212/src/main/scala/fix/ExperimentalSrc.scala

@@ -5,4 +5,4 @@ package fix
 
 class IterableSrc(it: Iterable[Int]) {
   it.iterator.sameElements(it)
-}
+}

scalafix/output/src/main/scala/fix/FoldSrc.scala renamed to scalafix/output212/src/main/scala/fix/FoldSrc.scala

@@ -9,4 +9,4 @@ class MethodRenames(xs: Map[Int, Int], ys: Set[Int]) {
   xs.filterInPlace{case (_, _) => true}
   xs.filterInPlace{case (x, y) => true}
   ys.filterInPlace(_ => true)
-}
+}

scalafix/output/src/main/scala/fix/LinearSeqSrc.scala renamed to scalafix/output212/src/main/scala/fix/LinearSeqSrc.scala

@@ -33,4 +33,4 @@ object Collectionstrawman_v0_Tuple3Zipped {
     List(1, 2, 3).lazyZip(Set(1, 2, 3)).lazyZip(Array(1))
   }
   def coll(x: Int): List[Int] = ???
-}
+}

scalafix/output/src/main/scala/fix/MutSetMapSrc.scala renamed to scalafix/output212/src/main/scala/fix/MutSetMapSrc.scala

@@ -0,0 +1,195 @@
+package fix
+
+import scalafix._
+import scalafix.syntax._
+import scalafix.util._
+import scala.meta._
+
+object CanBuildFrom {
+  def apply(paramss: List[List[Term.Param]],
+            body: Term,
+            ctx: RuleCtx,
+            collectionCanBuildFrom: SymbolMatcher,
+            nothing: SymbolMatcher)(implicit index: SemanticdbIndex): Patch = {
+    // CanBuildFrom has def apply() but not CanBuild
+    def emptyApply(param: Name): Boolean = {
+      import scala.meta.contrib._
+      val matchCbf = SymbolMatcher.exact(ctx.index.symbol(param).get)
+      body.exists{
+        case Term.Apply(Term.Select(matchCbf(_), _), Nil) => true
+        case Term.Apply(matchCbf(_), Nil) => true
+        case _ => false
+      }
+    }
+
+    paramss.flatten.collect{
+      case Term.Param(
+          List(Mod.Implicit()),
+          param,
+          Some(
+            Type.Apply(
+              cbf @ collectionCanBuildFrom(_),
+              List(p1, _, _)
+            )
+          ),
+          _
+        ) if !nothing.matches(p1) && !emptyApply(param) => new CanBuildFrom(param, cbf)
+    }.map(_.toBuildFrom(body, ctx)).asPatch
+  }
+}
+
+// example:
+// implicit cbf: collection.generic.CanBuildFrom[C0, Int, CC[Int]]
+// param: cbf
+// cbf  : collection.generic.CanBuildFrom
+case class CanBuildFrom(param: Name, cbf: Type) {
+  def toBuildFrom(body: Term, ctx: RuleCtx)(implicit index: SemanticdbIndex): Patch = {
+
+    val matchCbf = SymbolMatcher.exact(ctx.index.symbol(param).get)
+
+    // cbf(x) / cbf.apply(x) => cbf.newBuilder(x)
+    def replaceNewBuilder(tree: Tree, cbf2: Term, x: Term): Patch =
+      ctx.replaceTree(
+        tree,
+        Term.Apply(Term.Select(cbf2, Term.Name("newBuilder")), List(x)).syntax
+      )
+
+    val cbfCalls =
+      body.collect {
+        // cbf.apply(x)
+        case ap @ Term.Apply(sel @ Term.Select(cbf2 @ matchCbf(_), apply), List(x)) =>
+          replaceNewBuilder(ap, cbf2, x)
+
+        // cbf(x)
+        case ap @ Term.Apply(cbf2 @ matchCbf(_), List(x)) =>
+          replaceNewBuilder(ap, cbf2, x)
+      }.asPatch
+
+    val parameterType =
+      ctx.replaceTree(cbf, "collection.BuildFrom")
+
+    parameterType + cbfCalls
+  }
+}
+
+object CanBuildFromNothing {
+  def apply(paramss: List[List[Term.Param]],
+            body: Term,
+            ctx: RuleCtx,
+            collectionCanBuildFrom: SymbolMatcher,
+            nothing: SymbolMatcher,
+            toTpe: SymbolMatcher)(implicit index: SemanticdbIndex): (Patch, Set[Tree]) = {
+    val handledTo = Set.newBuilder[Tree]
+
+    val patches =
+      paramss.flatten.collect{
+        case
+          Term.Param(
+            List(Mod.Implicit()),
+            param,
+            Some(
+              tpe @ Type.Apply(
+                collectionCanBuildFrom(_),
+                List(
+                  nothing(_),
+                  t,
+                  cct @ Type.Apply(
+                    cc,
+                    _
+                  )
+                )
+              )
+            ),
+            _
+          ) => new CanBuildFromNothing(param, tpe, t, cct, cc, body, ctx, toTpe)
+      }.map{cbf =>
+        val (ps, ht) = cbf.toFactory
+        handledTo ++= ht
+        ps
+      }.asPatch
+
+    (patches, handledTo.result())
+  }
+}
+
+// example:
+// implicit cbf: collection.generic.CanBuildFrom[Nothing, Int, CC[Int]]
+//
+// param: cbf
+// tpe  : collection.generic.CanBuildFrom[Nothing, Int, CC[Int]]
+// cbf  : CanBuildFrom
+//   v  : Int
+// cct  : CC[Int]
+//  cc  : CC
+case class CanBuildFromNothing(param: Name,
+                               tpe: Type.Apply,
+                               t: Type,
+                               cct: Type.Apply,
+                               cc: Type,
+                               body: Term,
+                               ctx: RuleCtx,
+                               toTpe: SymbolMatcher) {
+  def toFactory(implicit index: SemanticdbIndex): (Patch, Set[Tree]) = {
+    val handledTo = Set.newBuilder[Tree]
+
+    val matchCbf = SymbolMatcher.exact(ctx.index.symbol(param).get)
+
+    // cbf() / cbf.apply => cbf.newBuilder
+    def replaceNewBuilder(tree: Tree, cbf2: Term): Patch =
+      ctx.replaceTree(tree, Term.Select(cbf2, Term.Name("newBuilder")).syntax)
+
+    // don't patch cbf.apply twice (cbf.apply and cbf.apply())
+    val visitedCbfCalls = scala.collection.mutable.Set[Tree]()
+
+    val cbfCalls =
+      body.collect {
+        // cbf.apply()
+        case ap @ Term.Apply(sel @ Term.Select(cbf2 @ matchCbf(_), apply), Nil) =>
+          visitedCbfCalls += sel
+          replaceNewBuilder(ap, cbf2)
+
+        // cbf.apply
+        case sel @ Term.Select(cbf2 @ matchCbf(_), ap) if (!visitedCbfCalls.contains(sel)) =>
+          replaceNewBuilder(sel, cbf2)
+
+        // cbf()
+        case ap @ Term.Apply(cbf2 @ matchCbf(_), Nil) =>
+          replaceNewBuilder(ap, cbf2)
+      }.asPatch
+
+
+    val matchCC = SymbolMatcher.exact(ctx.index.symbol(cc).get)
+
+    // e.to[CC] => e.to(cbf)
+    val toCalls =
+      body.collect {
+        case ap @ Term.ApplyType(Term.Select(_, to @ toTpe(_)), List(cc2 @ matchCC(_))) =>
+          handledTo += to
+
+          // e.to[CC](*cbf*) extract implicit parameter
+          val synth = ctx.index.synthetics.find(_.position.end == ap.pos.end).get
+          val Term.Apply(_, List(implicitCbf)) = synth.text.parse[Term].get
+
+          // This is a bit unsafe
+          // https://github.com/scalameta/scalameta/issues/1636
+          if (implicitCbf.syntax == param.syntax) {
+            trailingBrackets(to, ctx).map { case (open, close) =>
+              ctx.replaceTree(cc2, implicitCbf.syntax) +
+              ctx.replaceToken(open, "(") +
+              ctx.replaceToken(close, ")")
+            }.asPatch
+          } else Patch.empty
+
+      }.asPatch
+
+    // implicit cbf: collection.generic.CanBuildFrom[Nothing, Int, CC[Int]] =>
+    // implicit cbf: collection.Factory[Int, CC[Int]]
+    val parameterType =
+      ctx.replaceTree(
+        tpe,
+        Type.Apply(Type.Name("collection.Factory"), List(t, cct)).syntax
+      )
+
+    (parameterType + cbfCalls + toCalls, handledTo.result())
+  }
+}