Merge pull request #111 from MasseGuillaume/future-deprecated

Rewrite Future.{onFailure, onSuccess} => onComplete (fix #94)

Author: julienrf

build.sbt

@@ -77,8 +77,19 @@ lazy val scalafixRules = project
 
 // == Scalafix Test Setup ==
 
+lazy val sharedScalafixSettings = Seq(
+  scalacOptions ++= Seq(
+    "-deprecation",
+    "-encoding",
+    "UTF-8",
+    "-feature",
+    "-unchecked"
+  )
+)
+
 lazy val scalafixInput = project
   .in(file("scalafix/input"))
+  .settings(sharedScalafixSettings)
   .settings(dontPublish)
   .settings(
     scalaVersion := scalafixScala212,
@@ -88,22 +99,26 @@ lazy val scalafixInput = project
 
 lazy val scalafixOutput212 = project
   .in(file("scalafix/output212"))
+  .settings(sharedScalafixSettings)
   .settings(scalaVersion := scalafixScala212)
   .settings(dontPublish)
   .dependsOn(compatJVM)
 
 lazy val scalafixOutput213 = project
   .in(file("scalafix/output213"))
+  .settings(sharedScalafixSettings)
   .settings(scala213Settings)
   .settings(dontPublish)
 
 lazy val scalafixOutput213Failure = project
   .in(file("scalafix/output213-failure"))
+  .settings(sharedScalafixSettings)
   .settings(scala213Settings)
   .settings(dontPublish)
 
 lazy val scalafixTests = project
   .in(file("scalafix/tests"))
+  .settings(sharedScalafixSettings)
   .settings(dontPublish)
   .settings(
     scalaVersion := scalafixScala212,

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

@@ -0,0 +1,24 @@
+/*
+rule = "scala:fix.CrossCompat"
+ */
+package fix
+
+import scala.concurrent.{Future, ExecutionContext}
+import java.lang.Throwable
+
+class FutureSrc(fs: Future[Int])(implicit ec: ExecutionContext){
+  class E1 extends Throwable
+  case class E2(v: Int) extends Throwable
+  case object E3 extends Throwable
+
+  fs.onFailure {
+    case _: E1 => println("type pattern")
+    case E2(_) => println("constructor pattern")
+    case E3    => println("singleton pattern")
+  }
+
+  fs.onSuccess {
+    case x if x > 0 => println("x > 0")
+    case x if x < 0 => println("x < 0")
+  }(ec)
+}

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

@@ -0,0 +1,26 @@
+
+
+
+package fix
+
+import scala.concurrent.{Future, ExecutionContext}
+import java.lang.Throwable
+
+class FutureSrc(fs: Future[Int])(implicit ec: ExecutionContext){
+  class E1 extends Throwable
+  case class E2(v: Int) extends Throwable
+  case object E3 extends Throwable
+
+  fs.onComplete {
+    case scala.util.Failure(_: E1) => println("type pattern")
+    case scala.util.Failure(E2(_)) => println("constructor pattern")
+    case scala.util.Failure(E3)    => println("singleton pattern")
+    case _ => ()
+  }
+
+  fs.onComplete {
+    case scala.util.Success(x) if x > 0 => println("x > 0")
+    case scala.util.Success(x) if x < 0 => println("x < 0")
+    case _ => ()
+  }(ec)
+}

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

@@ -6,6 +6,8 @@ import scala.meta._
 
 import scala.collection.mutable
 
+import System.{lineSeparator => nl}
+
 trait CrossCompatibility {
   def isCrossCompatible: Boolean
 }
@@ -26,6 +28,9 @@ trait Stable212Base extends CrossCompatibility { self: SemanticRule =>
     normalized(s"_root_.scala.collection.TraversableOnce.`$op`.")
   }
 
+  val foldLeftSymbol = foldSymbol(isLeft = true)
+  val foldRightSymbol = foldSymbol(isLeft = false)
+
   val iterator = normalized("_root_.scala.collection.TraversableLike.toIterator.")
   val toTpe = normalized("_root_.scala.collection.TraversableLike.to.")
   val copyToBuffer = normalized("_root_.scala.collection.TraversableOnce.copyToBuffer.")
@@ -39,8 +44,8 @@ trait Stable212Base extends CrossCompatibility { self: SemanticRule =>
   val mutSetPlus = exact("_root_.scala.collection.mutable.SetLike#`+`(Ljava/lang/Object;)Lscala/collection/mutable/Set;.")
   val mutMapPlus = exact("_root_.scala.collection.mutable.MapLike#`+`(Lscala/Tuple2;)Lscala/collection/mutable/Map;.")
   val mutMapUpdate = exact("_root_.scala.collection.mutable.MapLike#updated(Ljava/lang/Object;Ljava/lang/Object;)Lscala/collection/mutable/Map;.")
-  val foldLeftSymbol = foldSymbol(isLeft = true)
-  val foldRightSymbol = foldSymbol(isLeft = false)
+  val `Future.onFailure` = exact("_root_.scala.concurrent.Future#onFailure(Lscala/PartialFunction;Lscala/concurrent/ExecutionContext;)V.")
+  val `Future.onSuccess` = exact("_root_.scala.concurrent.Future#onSuccess(Lscala/PartialFunction;Lscala/concurrent/ExecutionContext;)V.")
 
   val traversable = exact(
     "_root_.scala.package.Traversable#",
@@ -262,6 +267,29 @@ trait Stable212Base extends CrossCompatibility { self: SemanticRule =>
     compatImport + replaceToIterator + replaceTo
   }
 
+  def replaceFuture(ctx: RuleCtx): Patch = {
+
+    def toOnCompletePF(f: Tree, cases: List[Tree], tryApply: String): Patch = {
+      val indent = " " * cases.head.pos.startColumn
+
+      ctx.replaceTree(f, "onComplete") +
+      cases.map{ case Case(c, _, _) =>
+        ctx.addLeft(c, tryApply +"(") +
+        ctx.addRight(c, ")")
+      }.asPatch +
+      ctx.addRight(cases.last, nl + indent + "case _ => ()" )
+    }
+
+    ctx.tree.collect {
+      case Term.Apply(Term.Select(_, f @ `Future.onFailure`(_)), List(Term.PartialFunction(cases))) =>
+        toOnCompletePF(f, cases, "scala.util.Failure")
+
+      case Term.Apply(Term.Select(_, f @ `Future.onSuccess`(_)), List(Term.PartialFunction(cases))) =>
+        toOnCompletePF(f, cases, "scala.util.Success")
+
+    }.asPatch
+  }
+
   private val compatImportAdded = mutable.Set[Input]()
 
   def addCompatImport(ctx: RuleCtx): Patch = {
@@ -284,7 +312,7 @@ trait Stable212Base extends CrossCompatibility { self: SemanticRule =>
       replaceMutMapUpdated(ctx) +
       replaceArrayBuilderMake(ctx) +
       replaceIterableSameElements(ctx) +
-      replaceBreakout(ctx)
+      replaceBreakout(ctx) +
+      replaceFuture(ctx)
   }
-
 }

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

@@ -16,13 +16,16 @@ package object fix {
       close <- ctx.matchingParens.close(open)
     } yield (open, close)
 
-  def startsWithParens(tree: Tree): Boolean =
-    tree.tokens.headOption.map(_.is[Token.LeftParen]).getOrElse(false)
-
   def trailingParens(tree: Tree, ctx: RuleCtx): Option[(Token.LeftParen, Token.RightParen)] =
     for {
       end <- tree.tokens.lastOption
       open <- ctx.tokenList.find(end)(_.is[Token.LeftParen]).map(_.asInstanceOf[Token.LeftParen])
       close <- ctx.matchingParens.close(open)
     } yield (open, close)
+
+  def trailingApply(tree: Tree, ctx: RuleCtx): Option[(Token, Token)] = 
+    trailingParens(tree, ctx).orElse(trailingBrackets(tree, ctx))
+
+  def startsWithParens(tree: Tree): Boolean =
+    tree.tokens.headOption.map(_.is[Token.LeftParen]).getOrElse(false)
 }