feature: Inferred type for Scala 3

build.sbt

@@ -111,6 +111,14 @@ lazy val rules = projectMatrix
     description := "Built-in Scalafix rules",
     isFullCrossVersion,
     buildInfoSettingsForRules,
+    libraryDependencies ++= List(
+      ("org.scalameta" % "mtags-interfaces" % "1.3.4")
+        .exclude("org.eclipse.lsp4j", "org.eclipse.lsp4j")
+        .exclude("org.eclipse.lsp4j", "org.eclipse.lsp4j.jsonrpc"),
+      // latest version release for JDK 8, this will be dropped from interfaces at some point
+      "org.eclipse.lsp4j" % "org.eclipse.lsp4j" % "0.20.1",
+      coursierInterfaces
+    ),
     libraryDependencies ++= {
       if (!isScala3.value)
         Seq(
@@ -119,7 +127,10 @@ lazy val rules = projectMatrix
           semanticdbScalacCore,
           collectionCompat
         )
-      else Nil
+      else
+        List(
+          "org.scala-lang" %% "scala3-presentation-compiler" % scalaVersion.value
+        )
     },
     // companion of `.dependsOn(core)`
     // issue reported in https://github.com/sbt/sbt/issues/7405

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

@@ -1,4 +1,5 @@
 scalafix.internal.rule.DisableSyntax
+scalafix.internal.rule.ExplicitResultTypes
 scalafix.internal.rule.NoAutoTupling
 scalafix.internal.rule.NoValInForComprehension
 scalafix.internal.rule.OrganizeImports

scalafix-rules/src/main/scala-2/scalafix/internal/rule/ExplicitResultTypes.scala

@@ -3,23 +3,28 @@ package scalafix.internal.rule
 import scala.util.control.NonFatal
 
 import scala.meta._
-import scala.meta.contrib._
 import scala.meta.internal.pc.ScalafixGlobal
 
 import buildinfo.RulesBuildInfo
 import metaconfig.Configured
 import scalafix.internal.compat.CompilerCompat._
+import scalafix.internal.pc.PcExplicitResultTypes
 import scalafix.internal.v1.LazyValue
 import scalafix.patch.Patch
-import scalafix.util.TokenOps
 import scalafix.v1._
 
 final class ExplicitResultTypes(
-    config: ExplicitResultTypesConfig,
-    global: LazyValue[Option[ScalafixGlobal]]
-) extends SemanticRule("ExplicitResultTypes") {
-
-  def this() = this(ExplicitResultTypesConfig.default, LazyValue.now(None))
+    val config: ExplicitResultTypesConfig,
+    global: LazyValue[Option[ScalafixGlobal]],
+    fallback: LazyValue[Option[PcExplicitResultTypes]]
+) extends SemanticRule("ExplicitResultTypes")
+    with ExplicitResultTypesBase[Scala2Printer] {
+
+  def this() = this(
+    ExplicitResultTypesConfig.default,
+    LazyValue.now(None),
+    LazyValue.now(None)
+  )
 
   val compilerScalaVersion: String = RulesBuildInfo.scalaVersion
 
@@ -69,184 +74,63 @@ final class ExplicitResultTypes(
     if (
       config.scalacClasspath.nonEmpty && inputBinaryScalaVersion != runtimeBinaryScalaVersion
     ) {
-      Configured.error(
-        s"The ExplicitResultTypes rule needs to run with the same Scala binary version as the one used to compile target sources ($inputBinaryScalaVersion). " +
-          s"To fix this problem, either remove ExplicitResultTypes from .scalafix.conf or make sure Scalafix is loaded with $inputBinaryScalaVersion."
-      )
+      config.conf // Support deprecated explicitReturnTypes config
+        .getOrElse("explicitReturnTypes", "ExplicitResultTypes")(
+          ExplicitResultTypesConfig.default
+        )
+        .map(c =>
+          new ExplicitResultTypes(
+            c,
+            LazyValue.now(None),
+            LazyValue.now(Option(PcExplicitResultTypes.dynamic(config)))
+          )
+        )
     } else {
       config.conf // Support deprecated explicitReturnTypes config
         .getOrElse("explicitReturnTypes", "ExplicitResultTypes")(
           ExplicitResultTypesConfig.default
         )
-        .map(c => new ExplicitResultTypes(c, newGlobal))
+        .map(c => new ExplicitResultTypes(c, newGlobal, LazyValue.now(None)))
     }
   }
 
   override def fix(implicit ctx: SemanticDocument): Patch =
-    try unsafeFix()
-    catch {
+    try {
+      val typesLazy = global.value.map(new CompilerTypePrinter(_, config))
+      implicit val printer = new Scala2Printer(typesLazy, fallback)
+      unsafeFix()
+    } catch {
       case _: CompilerException if !config.fatalWarnings =>
         Patch.empty
     }
+}
 
-  def unsafeFix()(implicit ctx: SemanticDocument): Patch = {
-    global.value match {
-      case Some(value) =>
-        val types = new CompilerTypePrinter(value, config)
-        ctx.tree.collect {
-          case t @ Defn.Val(mods, Pat.Var(name) :: Nil, None, body)
-              if isRuleCandidate(t, name, mods, body) =>
-            fixDefinition(t, body, types)
-
-          case t @ Defn.Var(mods, Pat.Var(name) :: Nil, None, Some(body))
-              if isRuleCandidate(t, name, mods, body) =>
-            fixDefinition(t, body, types)
-
-          case t @ Defn.Def(mods, name, _, _, None, body)
-              if isRuleCandidate(t, name, mods, body) =>
-            fixDefinition(t, body, types)
-        }.asPatch
-      case None => Patch.empty
-    }
-  }
-
-  // Don't explicitly annotate vals when the right-hand body is a single call
-  // to `implicitly`. Prevents ambiguous implicit. Not annotating in such cases,
-  // this a common trick employed implicit-heavy code to workaround SI-2712.
-  // Context: https://gitter.im/typelevel/cats?at=584573151eb3d648695b4a50
-  private def isImplicitly(term: Term): Boolean = term match {
-    case Term.ApplyType(Term.Name("implicitly"), _) => true
-    case _ => false
-  }
-
-  def defnName(defn: Defn): Option[Name] = Option(defn).collect {
-    case Defn.Val(_, Pat.Var(name) :: Nil, _, _) => name
-    case Defn.Var(_, Pat.Var(name) :: Nil, _, _) => name
-    case Defn.Def(_, name, _, _, _, _) => name
-  }
-
-  def defnBody(defn: Defn): Option[Term] = Option(defn).collect {
-    case Defn.Val(_, _, _, term) => term
-    case Defn.Var(_, _, _, Some(term)) => term
-    case Defn.Def(_, _, _, _, _, term) => term
-  }
-
-  def visibility(mods: Iterable[Mod]): MemberVisibility =
-    mods
-      .collectFirst {
-        case _: Mod.Private => MemberVisibility.Private
-        case _: Mod.Protected => MemberVisibility.Protected
-      }
-      .getOrElse(MemberVisibility.Public)
-
-  def kind(defn: Defn): Option[MemberKind] = Option(defn).collect {
-    case _: Defn.Val => MemberKind.Val
-    case _: Defn.Def => MemberKind.Def
-    case _: Defn.Var => MemberKind.Var
-  }
-
-  def isRuleCandidate[D <: Defn](
-      defn: D,
-      nm: Name,
-      mods: Iterable[Mod],
-      body: Term
-  )(implicit ev: Extract[D, Mod], ctx: SemanticDocument): Boolean = {
-    import config._
-
-    def matchesMemberVisibility(): Boolean =
-      memberVisibility.contains(visibility(mods))
-
-    def matchesMemberKind(): Boolean =
-      kind(defn).exists(memberKind.contains)
-
-    def isFinalLiteralVal: Boolean =
-      defn.is[Defn.Val] &&
-        mods.exists(_.is[Mod.Final]) &&
-        body.is[Lit]
-
-    def matchesSimpleDefinition(): Boolean =
-      config.skipSimpleDefinitions.isSimpleDefinition(body)
-
-    def isImplicit: Boolean =
-      defn.hasMod(mod"implicit") && !isImplicitly(body)
-
-    def hasParentWihTemplate: Boolean =
-      defn.parent.exists(_.is[Template.Body])
-
-    def qualifyingImplicit: Boolean =
-      isImplicit && !isFinalLiteralVal
-
-    def matchesConfig: Boolean =
-      matchesMemberKind && matchesMemberVisibility && !matchesSimpleDefinition
-
-    def qualifyingNonImplicit: Boolean = {
-      !onlyImplicits &&
-      hasParentWihTemplate &&
-      !defn.hasMod(mod"implicit")
-    }
-
-    matchesConfig && {
-      qualifyingImplicit || qualifyingNonImplicit
-    }
-  }
-
+class Scala2Printer(
+    globalPrinter: Option[CompilerTypePrinter],
+    fallback: LazyValue[Option[PcExplicitResultTypes]]
+) extends Printer {
   def defnType(
       defn: Defn,
       replace: Token,
-      space: String,
-      types: CompilerTypePrinter
+      space: String
   )(implicit
       ctx: SemanticDocument
-  ): Option[Patch] =
-    for {
-      name <- defnName(defn)
-      defnSymbol <- name.symbol.asNonEmpty
-      patch <- types.toPatch(name.pos, defnSymbol, replace, defn, space)
-    } yield patch
-
-  def fixDefinition(defn: Defn, body: Term, types: CompilerTypePrinter)(implicit
-      ctx: SemanticDocument
-  ): Patch = {
-    val lst = ctx.tokenList
-    val option = SymbolMatcher.exact("scala/Option.")
-    val list = SymbolMatcher.exact(
-      "scala/package.List.",
-      "scala/collection/immutable/List."
-    )
-    val seq = SymbolMatcher.exact(
-      "scala/package.Seq.",
-      "scala/collection/Seq.",
-      "scala/collection/immutable/Seq."
-    )
-    def patchEmptyValue(term: Term): Patch = {
-      term match {
-        case q"${option(_)}.empty[$_]" =>
-          Patch.replaceTree(term, "None")
-        case q"${list(_)}.empty[$_]" =>
-          Patch.replaceTree(term, "Nil")
-        case q"${seq(_)}.empty[$_]" =>
-          Patch.replaceTree(term, "Nil")
-        case _ =>
-          Patch.empty
-      }
+  ): Option[Patch] = {
+
+    globalPrinter match {
+      case Some(types) =>
+        for {
+          name <- ExplicitResultTypesBase.defnName(defn)
+          defnSymbol <- name.symbol.asNonEmpty
+          patch <- types.toPatch(name.pos, defnSymbol, replace, defn, space)
+        } yield {
+          patch
+        }
+      case None =>
+        fallback.value.flatMap { fallbackExplicit =>
+          fallbackExplicit.defnType(replace)
+        }
     }
-    import lst._
-    for {
-      start <- defn.tokens.headOption
-      end <- body.tokens.headOption
-      // Left-hand side tokens in definition.
-      // Example: `val x = ` from `val x = rhs.banana`
-      lhsTokens = slice(start, end)
-      replace <- lhsTokens.reverseIterator.find(x =>
-        !x.is[Token.Equals] && !x.is[Trivia]
-      )
-      space = {
-        if (TokenOps.needsLeadingSpaceBeforeColon(replace)) " "
-        else ""
-      }
-      typePatch <- defnType(defn, replace, space, types)
-      valuePatchOpt = defnBody(defn).map(patchEmptyValue)
-    } yield typePatch + valuePatchOpt
-  }.asPatch.atomic
 
+  }
 }

scalafix-rules/src/main/scala-3/scalafix/internal/rule/ExplicitResultTypes.scala

@@ -0,0 +1,84 @@
+package scalafix.internal.rule
+
+import scala.meta.*
+
+import buildinfo.RulesBuildInfo
+import dotty.tools.pc.ScalaPresentationCompiler
+import metaconfig.Configured
+import scalafix.internal.pc.PcExplicitResultTypes
+import scalafix.patch.Patch
+import scalafix.v1.*
+
+final class ExplicitResultTypes(
+    val config: ExplicitResultTypesConfig,
+    fallback: Option[PcExplicitResultTypes]
+) extends SemanticRule("ExplicitResultTypes")
+    with ExplicitResultTypesBase[Scala3Printer] {
+
+  def this() = this(ExplicitResultTypesConfig.default, None)
+
+  val compilerScalaVersion: String = RulesBuildInfo.scalaVersion
+
+  private def toBinaryVersion(v: String) = v.split('.').take(2).mkString(".")
+
+  override def description: String =
+    "Inserts type annotations for inferred public members."
+
+  override def isRewrite: Boolean = true
+
+  override def afterComplete(): Unit = {
+    shutdownCompiler()
+  }
+
+  private def shutdownCompiler(): Unit = {
+    fallback.foreach(_.shutdownCompiler())
+  }
+
+  override def withConfiguration(config: Configuration): Configured[Rule] = {
+    config.conf // Support deprecated explicitReturnTypes config
+      .getOrElse("explicitReturnTypes", "ExplicitResultTypes")(
+        ExplicitResultTypesConfig.default
+      )
+      .map(c =>
+        new ExplicitResultTypes(
+          c,
+          Option {
+            if (
+              toBinaryVersion(config.scalaVersion) == toBinaryVersion(
+                compilerScalaVersion
+              )
+            )
+              PcExplicitResultTypes
+                .static(config, new ScalaPresentationCompiler())
+            else
+              PcExplicitResultTypes.dynamic(config)
+          }
+        )
+      )
+  }
+
+  override def fix(implicit ctx: SemanticDocument): Patch =
+    try {
+      implicit val printer = new Scala3Printer(fallback)
+      unsafeFix()
+    } catch {
+      case _: Throwable if !config.fatalWarnings =>
+        Patch.empty
+    }
+
+}
+
+class Scala3Printer(
+    fallback: Option[PcExplicitResultTypes]
+) extends Printer {
+
+  def defnType(
+      defn: Defn,
+      replace: Token,
+      space: String
+  )(implicit
+      ctx: SemanticDocument
+  ): Option[Patch] = {
+    fallback.flatMap(_.defnType(replace))
+  }
+}