scalafix rule for Future.traverse

Author: gmethvin

.gitignore

@@ -0,0 +1,18 @@
+target/
+bin/
+lib_managed/
+src_managed/
+.settings/
+.classpath
+.project
+.cache
+*.class
+*.log
+*.iml
+.idea
+.idea_modules
+.bloop
+.metals
+metals.sbt
+.vscode
+.bsp

.scalafmt.conf

@@ -0,0 +1,2 @@
+version = "3.7.15"
+runner.dialect = scala213

README.md

@@ -0,0 +1,41 @@
+# Iterable Scalafix rules
+
+Repository of custom scalafix rules for Iterable projects.
+
+## Usage
+
+This library is not published anywhere yet, so you'll first need to build and publish locally with:
+```
+sbt publishLocal
+```
+Then you can reference the published library version in your project.
+
+For example, you can run version `0.1.0` of `NoFutureTraverse` dynamically in the `sbt` console:
+
+```
+scalafix dependency:[email protected]::scalafix-rules:0.1.0
+```
+
+Replace the version `0.1.0` with the version you published.
+
+To run the rules by default with `scalafix` or `scalafixAll`, you'll need to add a library dependency in `build.sbt`:
+
+```scala
+ThisBuild / libraryDependencies += "com.iterable" %% "scalafix-rules" % "0.1.0" % ScalafixConfig
+```
+
+Then you can add the rules in your `.scalafix.conf` file, e.g.:
+
+```hocon
+rules = [
+  # ...
+  NoFutureTraverse # validate that Future.traverse is not used
+]
+
+# Configuration for the NoFutureTraverse rule
+NoFutureTraverse {
+  isError = true
+}
+```
+
+

build.sbt

@@ -0,0 +1,42 @@
+lazy val V = _root_.scalafix.sbt.BuildInfo
+inThisBuild(
+  List(
+    scalaVersion := V.scala213,
+    crossScalaVersions := List(V.scala213),
+    addCompilerPlugin(scalafixSemanticdb),
+    scalacOptions += "-Yrangepos",
+    organization := "com.iterable",
+    homepage := Some(url("https://github.com/iterable/scalafix-rules")),
+    licenses := List(
+      "Apache-2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0")
+    ),
+    developers := List()
+  )
+)
+
+publish / skip := true
+
+lazy val rules = project.settings(
+  moduleName := "scalafix-rules",
+  libraryDependencies += "ch.epfl.scala" %% "scalafix-core" % V.scalafixVersion
+)
+
+lazy val input = project
+  .settings(publish / skip := true)
+
+lazy val output = project
+  .settings(publish / skip := true)
+
+lazy val tests = project
+  .settings(
+    libraryDependencies += "ch.epfl.scala" % "scalafix-testkit" % V.scalafixVersion % Test cross CrossVersion.full,
+    scalafixTestkitOutputSourceDirectories :=
+      (output / Compile / sourceDirectories).value,
+    scalafixTestkitInputSourceDirectories :=
+      (input / Compile / sourceDirectories).value,
+    scalafixTestkitInputClasspath :=
+      (input / Compile / fullClasspath).value
+  )
+  .settings(publish / skip := true)
+  .dependsOn(input, rules)
+  .enablePlugins(ScalafixTestkitPlugin)

input/src/main/scala/fix/FutureSequenceTest.scala

@@ -0,0 +1,15 @@
+/*
+rule = NoFutureTraverse
+ */
+package test
+
+import scala.concurrent.Future
+import scala.concurrent.Await
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.duration._
+
+object FutureSequenceTest {
+  val futures = List(Future { "hello" }, Future { "world" })
+  val result = Future.sequence(futures).map(_.mkString) // assert: NoFutureTraverse
+  println(Await.result(result, 1.second))
+}

input/src/main/scala/fix/FutureTraverseTest.scala

@@ -0,0 +1,15 @@
+/*
+rule = NoFutureTraverse
+ */
+package test
+
+import scala.concurrent.Future
+import scala.concurrent.Await
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.duration._
+
+object FutureTraverseTest {
+  val items = List("hello", "world")
+  val result = Future.traverse(items)(item => Future(item.length)).map(_.sum) // assert: NoFutureTraverse
+  println(Await.result(result, 1.second))
+}

project/build.properties

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

project/plugins.sbt

@@ -0,0 +1,3 @@
+addSbtPlugin("com.github.sbt" % "sbt-ci-release" % "1.9.2")
+addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.13.0")
+dependencyOverrides += "ch.epfl.scala" % "scalafix-interfaces" % "0.13.0"

rules/src/main/resources/META-INF/services/scalafix.v1.Rule

@@ -0,0 +1 @@
+fix.NoFutureTraverse

rules/src/main/scala/fix/NoFutureTraverse.scala

@@ -0,0 +1,45 @@
+package fix
+
+import metaconfig.ConfDecoder
+import metaconfig.Configured
+import metaconfig.generic.Surface
+import scala.meta._
+import scalafix.lint._
+import scalafix.v1._
+
+case class NoFutureTraverseConfig(
+  isError: Boolean = false
+)
+object NoFutureTraverseConfig {
+  implicit val surface: Surface[NoFutureTraverseConfig] =
+    metaconfig.generic.deriveSurface
+  implicit val decoder: ConfDecoder[NoFutureTraverseConfig] =
+    metaconfig.generic.deriveDecoder(NoFutureTraverseConfig())
+}
+
+class NoFutureTraverse(config: NoFutureTraverseConfig) extends SemanticRule("NoFutureTraverse") {
+
+  case class Deprecation(position: Position, name: String) extends Diagnostic {
+    override def message = s"$name is deprecated"
+    override def severity = if (config.isError) LintSeverity.Error else LintSeverity.Warning
+  }
+
+  def this() = this(NoFutureTraverseConfig())
+
+  override def withConfiguration(config: Configuration): Configured[Rule] =
+    config.conf
+      .getOrElse("NoFutureTraverse")(this.config)
+      .map(c => new NoFutureTraverse(c))
+
+  val futureTraverse = SymbolMatcher.normalized("scala.concurrent.Future.traverse")
+  val futureSequence = SymbolMatcher.normalized("scala.concurrent.Future.sequence")
+
+  override def fix(implicit doc: SemanticDocument): Patch = {
+    doc.tree.collect {
+      case t @ Term.Apply(futureTraverse(_), _) =>
+        Patch.lint(Deprecation(t.pos, "Future.traverse"))
+      case t @ Term.Apply(futureSequence(_), _) =>
+        Patch.lint(Deprecation(t.pos, "Future.sequence"))
+    }.asPatch
+  }
+}