feat: implicit conversions

Author: ingarabr

input/src/main/scala-3/fix/ImplicitConversionsTest.scala

@@ -0,0 +1,19 @@
+/*
+rule = ImplicitConversions
+ */
+
+package fix
+
+import scala.language.implicitConversions
+
+// format: off
+object ImplicitConversionsTest {
+  implicit def conv1(x: Int): String = x.toString
+
+  implicit val conv2: Long => String = _.toString
+
+  def foo(x: Int)(implicit conv: Int => String): String = x
+
+  def foo2(x: Int)(implicit conv: (Int, Int) => String): String = x
+}
+// format: on

output/src/main/scala-3/fix/ImplicitConversionsTest.scala

@@ -0,0 +1,15 @@
+package fix
+
+import scala.language.implicitConversions
+
+// format: off
+object ImplicitConversionsTest {
+  implicit val conv1: Conversion[Int, String] = (x: Int) => x.toString
+
+  implicit val conv2: Conversion[Long, String] = _.toString
+
+  def foo(x: Int)(implicit conv: Conversion[Int, String]): String = x
+
+  def foo2(x: Int)(implicit conv: Conversion[(Int, Int), String]): String = x
+}
+// format: on

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

@@ -2,4 +2,5 @@ fix.SemiAuto
 fix.GivenAndUsing
 fix.PackageObjectExport
 fix.DropModThis
-fix.WildcardInitializer
+fix.WildcardInitializer
+fix.ImplicitConversions

rules/src/main/scala/fix/ImplicitConversions.scala

@@ -0,0 +1,67 @@
+package fix
+
+import fix.ImplicitConversions.LastImplicitTypeFunctionParams
+import scalafix.v1.{Patch, SemanticDocument, SemanticRule}
+
+import scala.meta._
+import scala.meta.tokens.Token
+
+class ImplicitConversions extends SemanticRule("ImplicitConversions") {
+
+  override def fix(implicit doc: SemanticDocument): Patch = {
+
+    doc.tree.collect {
+      case Defn.Def(_, _, _, LastImplicitTypeFunctionParams(typeFunctions), _, _) =>
+        typeFunctions.foldRight(Patch.empty) { case (tf, patches) =>
+          patches + Patch.replaceTree(tf, conversionCode(tf.params, tf.res))
+        }
+
+      case d @ Defn.Def(mods, Term.Name(_), _, (firstParam :: Nil) :: Nil, ot @ Some(outType: Type.Name), _)
+          if mods.exists(_.is[Mod.Implicit]) && firstParam.mods.forall(_.isNot[Mod.Implicit]) =>
+        (for {
+          defkw <- d.tokens.find(_.is[Token.KwDef]).map(Patch.replaceToken(_, "val"))
+          eqSign <- d.tokens.find(_.is[Token.Equals])
+          returnTypeTree <- ot
+          retType <- firstParam.decltpe
+          argTokens = d.tokens.dropWhile(_.isNot[Token.LeftParen]).dropRightWhile(_.isNot[Token.RightParen])
+        } yield defkw +
+          Patch.removeTokens(argTokens) +
+          Patch.addRight(eqSign, s" ${argTokens.toString()} =>") +
+          Patch.replaceTree(returnTypeTree, conversionCode(retType, outType))).asPatch
+
+      case Defn.Val(mods, _, Some(ts: Type.Function), _) if mods.exists(_.is[Mod.Implicit]) =>
+        ts.params match {
+          case inType :: Nil => Patch.replaceTree(ts, conversionCode(inType, ts.res))
+          case _             => Patch.empty
+        }
+    }.asPatch
+  }
+
+  private def conversionCode(inType: Type, retType: Type): String =
+    conversionCode(inType :: Nil, retType)
+
+  private def conversionCode(inType: List[Type], retType: Type): String = {
+    val inStr = inType match {
+      case one :: Nil => one.toString()
+      case many       => many.map(_.toString()).mkString("(", ", ", ")")
+    }
+    s"Conversion[$inStr, $retType]"
+  }
+}
+
+object ImplicitConversions {
+
+  object LastImplicitTypeFunctionParams {
+    def unapply(params: List[List[Term.Param]]): Option[List[Type.Function]] = {
+      val lastParams = params.lastOption
+      if (lastParams.exists(_.exists(_.mods.exists(_.is[Mod.Implicit])))) {
+        val tfs = lastParams.toList
+          .flatMap(_.map(_.decltpe))
+          .collect { case Some(tf: Type.Function) => tf }
+        if (tfs.isEmpty) None
+        else Some(tfs)
+      } else None
+    }
+  }
+
+}