Rewrite for strict reverseMap and filterKeys (fix scala#85)

Author: MasseGuillaume

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

@@ -0,0 +1,13 @@
+/*
+rule = "scala:fix.Roughly"
+Roughly.strictMapValues = true
+Roughly.strictFilterKeys = true
+Roughly.strictReverseMap = true
+*/
+package fix
+
+class Roughly212Src(map: Map[Int, Int], seq: Seq[Int]) {
+  map.mapValues(_ + 1): Map[Int, Int]
+  map.filterKeys(_ > 1): Map[Int, Int]
+  seq.reverseMap(_ + 1): Seq[Int]
+}

scalafix/input/src/main/scala/fix/RoughlyStreamToLazyListSrc.scala renamed to scalafix/input/src/main/scala/fix/Roughly213Src.scala

@@ -1,9 +1,13 @@
 /*
-rule = "scala:fix.RoughlyStreamToLazyList"
+rule = "scala:fix.Roughly"
+Roughly = {
+  withLazyAppendedAll = true
+  withLazyList = true
+}
  */
 package fix
 
-class RoughlyStreamToLazyListSrc() {
+class Roughly213Src() {
   val s = Stream(1, 2, 3)
   s.append(List(4, 5, 6))
   1 #:: 2 #:: 3 #:: Stream.Empty

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

@@ -0,0 +1,10 @@
+
+
+
+package fix
+
+class Roughly212Src(map: Map[Int, Int], seq: Seq[Int]) {
+  map.mapValues(_ + 1).toMap: Map[Int, Int]
+  map.filterKeys(_ > 1).toMap: Map[Int, Int]
+  seq.reverseMap(_ + 1).toSeq: Seq[Int]
+}

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

@@ -3,7 +3,7 @@
 
 package fix
 
-class RoughlyStreamToLazyListSrc() {
+class Roughly213Src() {
   val s = LazyList(1, 2, 3)
   s.lazyAppendedAll(List(4, 5, 6))
   1 #:: 2 #:: 3 #:: LazyList.Empty

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

@@ -0,0 +1,100 @@
+package fix
+
+import scalafix._
+import scalafix.util._
+import scala.meta._
+
+import metaconfig.{ConfDecoder, Conf, Configured}
+import metaconfig.annotation.Description
+import metaconfig.annotation.ExampleValue
+import metaconfig.generic
+import metaconfig.generic.Surface
+
+/* 2.12 Cross-Compatible
+ *
+ * This rules is *roughly* correct, they compile but might have a different runtime semantic
+ *
+ * Map.{mapValues, filterKeys}, Seq.reverseMap were lazy but with a strict interface
+ * (ex returning Map where they should return MapView).
+ *
+ * LazyList has a lazy head, were Stream has a strict head
+ *
+ */
+final case class Roughly(index: SemanticdbIndex, config: RoughlyConfig) extends SemanticRule(index, "Roughly") {
+  def this(index: SemanticdbIndex) = this(index, RoughlyConfig.default)
+
+  val mapValues =
+    SymbolMatcher.exact(
+      Symbol("_root_.scala.collection.immutable.MapLike#mapValues(Lscala/Function1;)Lscala/collection/immutable/Map;.")
+    )
+
+  val reverseMap =
+    SymbolMatcher.exact(
+      Symbol("_root_.scala.collection.SeqLike#reverseMap(Lscala/Function1;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.")
+    )
+
+  val filterKeys =
+    SymbolMatcher.exact(
+      Symbol("_root_.scala.collection.immutable.MapLike#filterKeys(Lscala/Function1;)Lscala/collection/immutable/Map;.")
+    )
+
+  val streamAppend = SymbolMatcher.normalized(
+    Symbol("_root_.scala.collection.immutable.Stream.append.")
+  )
+
+  def replaceSymbols(ctx: RuleCtx): Patch = {
+    if (config.withLazyList) {
+      ctx.replaceSymbols(
+        "scala.Stream" -> "scala.LazyList",
+        "scala.collection.immutable.Stream" -> "scala.collection.immutable.LazyList"
+      )
+    } else Patch.empty
+  }
+
+  override def description: String = ""
+
+  override def init(config: Conf): Configured[Rule] =
+    config
+      .getOrElse("roughly", "Roughly")(RoughlyConfig.default)
+      .map(Roughly(index, _))
+
+  override def fix(ctx: RuleCtx): Patch = {
+    import config._
+
+    val collectFixes =
+      ctx.tree.collect {
+        case ap @ Term.Apply(Term.Select(_, mapValues(_)), List(_)) if strictMapValues =>
+          ctx.addRight(ap, ".toMap")
+
+        case ap @ Term.Apply(Term.Select(_, filterKeys(_)), List(_)) if strictFilterKeys =>
+          ctx.addRight(ap, ".toMap")
+
+        case ap @ Term.Apply(Term.Select(_, reverseMap(_)), List(_)) if strictReverseMap =>
+          ctx.addRight(ap, ".toSeq")
+
+        case streamAppend(t: Name) if withLazyAppendedAll =>
+          ctx.replaceTree(t, "lazyAppendedAll")
+
+        case ap @ Term.Apply(Term.Select(_, op), List(_)) =>
+          println(ctx.index.symbol(op))
+          Patch.empty
+
+      }.asPatch
+
+    collectFixes + replaceSymbols(ctx)
+  }
+}
+
+case class RoughlyConfig(
+  strictMapValues: Boolean = false,
+  strictFilterKeys: Boolean = false,
+  strictReverseMap: Boolean = false,
+  withLazyAppendedAll: Boolean = false,
+  withLazyList: Boolean = false
+)
+
+object RoughlyConfig {
+  val default: RoughlyConfig = RoughlyConfig()
+  implicit val surface: Surface[RoughlyConfig] = generic.deriveSurface[RoughlyConfig]
+  implicit val decoder: ConfDecoder[RoughlyConfig] = generic.deriveDecoder[RoughlyConfig](default)
+}

scalafix/output213/src/main/scala/fix/RoughlyStreamToLazyListSrc.scala renamed to scalafix/output213/src/main/scala/fix/Roughly213Src.scala

@@ -17,5 +17,5 @@ class ScalafixTests
 
   runAllTests()
   // to run only one test:
-  // testsToRun.filter(_.filename.toNIO.getFileName.toString == "IterableSrc.scala" ).foreach(runOn)
+  // testsToRun.filter(_.filename.toNIO.getFileName.toString == "Playground.scala" ).foreach(runOn)
 }