Add -quickfix compiler option to apply quick fixes to source files

With 2.13.12 the compiler starts providing quick fixes with certain
warnings and errors. Typically these are presented in IDEs, however
it can also be practical to have the compiler directly patch the source
files.

From `-quickfix:help`:

```
Apply quick fixes provided by the compiler for warnings and errors to source files.
Syntax: -quickfix:<filter>,...,<filter>

<filter> syntax is the same as for configurable warnings, see `-Wconf:help`. Examples:
  -quickfix:any                    apply all available quick fixes
  -quickfix:msg=Auto-application   apply quick fixes where the message contains "Auto-application"

Use `-Wconf:any:warning-verbose` to display applicable message filters with each warning.
```

Author: lrytz

src/compiler/scala/tools/nsc/Reporting.scala

@@ -14,12 +14,15 @@ package scala
 package tools
 package nsc
 
+import java.io.IOException
+import java.nio.charset.Charset
+import java.nio.file.{Files, Path, Paths}
 import java.util.regex.PatternSyntaxException
-import scala.annotation.nowarn
+import scala.annotation.{nowarn, tailrec}
 import scala.collection.mutable
 import scala.reflect.internal
 import scala.reflect.internal.util.StringOps.countElementsAsString
-import scala.reflect.internal.util.{CodeAction, NoSourceFile, Position, SourceFile}
+import scala.reflect.internal.util.{CodeAction, NoSourceFile, Position, SourceFile, TextEdit}
 import scala.tools.nsc.Reporting.Version.{NonParseableVersion, ParseableVersion}
 import scala.tools.nsc.Reporting._
 import scala.tools.nsc.settings.NoScalaVersion
@@ -62,13 +65,50 @@ trait Reporting extends internal.Reporting { self: ast.Positions with Compilatio
         else conf
     }
 
+    private lazy val quickfixFilters = {
+      if (settings.quickfix.isSetByUser && settings.quickfix.value.isEmpty) {
+        globalError(s"Missing message filter for `-quickfix`; see `-quickfix:help` or use `-quickfix:any` to apply all available quick fixes.")
+        Nil
+      } else {
+        val parsed = settings.quickfix.value.map(WConf.parseFilter(_, rootDirPrefix))
+        val msgs = parsed.collect { case Left(msg) => msg }
+        if (msgs.nonEmpty) {
+          globalError(s"Failed to parse `-quickfix` filters: ${settings.quickfix.value.mkString(",")}\n${msgs.mkString("\n")}")
+          Nil
+        } else parsed.collect { case Right(f) => f }
+      }
+    }
+
+    private val skipRewriteAction = Set(Action.WarningSummary, Action.InfoSummary, Action.Silent)
+
+    private def registerTextEdit(m: Message): Boolean =
+      if (quickfixFilters.exists(f => f.matches(m))) {
+        textEdits.addAll(m.actions.flatMap(_.edits))
+        true
+      }
+      else false
+
+    private def registerErrorTextEdit(pos: Position, msg: String, actions: List[CodeAction]): Boolean = {
+      val matches = quickfixFilters.exists({
+        case MessageFilter.Any => true
+        case mp: MessageFilter.MessagePattern => mp.check(msg)
+        case sp: MessageFilter.SourcePattern => sp.check(pos)
+        case _ => false
+      })
+      if (matches)
+        textEdits.addAll(actions.flatMap(_.edits))
+      matches
+    }
+
     private val summarizedWarnings: mutable.Map[WarningCategory, mutable.LinkedHashMap[Position, Message]] = mutable.HashMap.empty
     private val summarizedInfos: mutable.Map[WarningCategory, mutable.LinkedHashMap[Position, Message]] = mutable.HashMap.empty
 
     private val suppressions: mutable.LinkedHashMap[SourceFile, mutable.ListBuffer[Suppression]] = mutable.LinkedHashMap.empty
     private val suppressionsComplete: mutable.Set[SourceFile] = mutable.Set.empty
     private val suspendedMessages: mutable.LinkedHashMap[SourceFile, mutable.LinkedHashSet[Message]] = mutable.LinkedHashMap.empty
 
+    private val textEdits: mutable.Set[TextEdit] = mutable.Set.empty
+
     // Used in REPL. The old run is used for parsing. Don't discard its suspended warnings.
     def initFrom(old: PerRunReporting): Unit = {
       suspendedMessages ++= old.suspendedMessages
@@ -100,6 +140,10 @@ trait Reporting extends internal.Reporting { self: ast.Positions with Compilatio
           sups   <- suppressions.remove(source)
           sup    <- sups.reverse
         } if (!sup.used && !sup.synthetic) issueWarning(Message.Plain(sup.annotPos, "@nowarn annotation does not suppress any warnings", WarningCategory.UnusedNowarn, "", Nil))
+
+      // apply quick fixes
+      quickfix(textEdits)
+      textEdits.clear()
     }
 
     def reportSuspendedMessages(unit: CompilationUnit): Unit = {
@@ -119,6 +163,14 @@ trait Reporting extends internal.Reporting { self: ast.Positions with Compilatio
     }
 
     private def issueWarning(warning: Message): Unit = {
+      val action = wconf.action(warning)
+
+      val quickfixed = {
+        if (!skipRewriteAction(action) && registerTextEdit(warning)) s"[rewritten by -quickfix] ${warning.msg}"
+        else if (warning.actions.exists(_.edits.nonEmpty)) s"[quick fix available] ${warning.msg}"
+        else warning.msg
+      }
+
       def ifNonEmpty(kind: String, filter: String) = if (filter.nonEmpty) s", $kind=$filter" else ""
       def filterHelp =
         s"msg=<part of the message>, cat=${warning.category.name}" +
@@ -133,12 +185,13 @@ trait Reporting extends internal.Reporting { self: ast.Positions with Compilatio
           "\nScala 3 migration messages are errors under -Xsource:3. Use -Wconf / @nowarn to filter them or add -Xmigration to demote them to warnings."
         else ""
       def helpMsg(kind: String, isError: Boolean = false) =
-        s"${warning.msg}${scala3migration(isError)}\nApplicable -Wconf / @nowarn filters for this $kind: $filterHelp"
-      wconf.action(warning) match {
+        s"$quickfixed${scala3migration(isError)}\nApplicable -Wconf / @nowarn filters for this $kind: $filterHelp"
+
+      action match {
         case Action.Error => reporter.error(warning.pos, helpMsg("fatal warning", isError = true), warning.actions)
-        case Action.Warning => reporter.warning(warning.pos, warning.msg, warning.actions)
+        case Action.Warning => reporter.warning(warning.pos, quickfixed, warning.actions)
         case Action.WarningVerbose => reporter.warning(warning.pos, helpMsg("warning"), warning.actions)
-        case Action.Info => reporter.echo(warning.pos, warning.msg, warning.actions)
+        case Action.Info => reporter.echo(warning.pos, quickfixed, warning.actions)
         case Action.InfoVerbose => reporter.echo(warning.pos, helpMsg("message"), warning.actions)
         case a @ (Action.WarningSummary | Action.InfoSummary) =>
           val m = summaryMap(a, warning.category.summaryCategory)
@@ -299,6 +352,16 @@ trait Reporting extends internal.Reporting { self: ast.Positions with Compilatio
     def warning(pos: Position, msg: String, category: WarningCategory, site: Symbol, origin: String): Unit =
       issueIfNotSuppressed(Message.Origin(pos, msg, category, siteName(site), origin, actions = Nil))
 
+    // Remember CodeActions that match `-quickfix` and report the error through the reporter
+    def error(pos: Position, msg: String, actions: List[CodeAction]): Unit = {
+      val quickfixed = {
+        if (registerErrorTextEdit(pos, msg, actions)) s"[rewritten by -quickfix] $msg"
+        else if (actions.exists(_.edits.nonEmpty)) s"[quick fix available] $msg"
+        else msg
+      }
+      reporter.error(pos, quickfixed, actions)
+    }
+
     // used by Global.deprecationWarnings, which is used by sbt
     def deprecationWarnings: List[(Position, String)] = summaryMap(Action.WarningSummary, WarningCategory.Deprecation).toList.map(p => (p._1, p._2.msg))
     def uncheckedWarnings: List[(Position, String)]   = summaryMap(Action.WarningSummary, WarningCategory.Unchecked).toList.map(p => (p._1, p._2.msg))
@@ -330,6 +393,91 @@ trait Reporting extends internal.Reporting { self: ast.Positions with Compilatio
       if (settings.fatalWarnings.value && reporter.hasWarnings)
         reporter.error(NoPosition, "No warnings can be incurred under -Werror.")
     }
+
+    private object quickfix {
+      /** Source code at a position. Either a line with caret (offset), else the code at the range position. */
+      def codeOf(pos: Position, source: SourceFile): String =
+        if (pos.start < pos.end) new String(source.content.slice(pos.start, pos.end))
+        else {
+          val line = source.offsetToLine(pos.point)
+          val code = source.lines(line).next()
+          val caret = " " * (pos.point - source.lineToOffset(line)) + "^"
+          s"$code\n$caret"
+        }
+
+
+      def checkNoOverlap(patches: List[TextEdit], source: SourceFile): Boolean = {
+        var ok = true
+        for (List(p1, p2) <- patches.sliding(2) if p1.position.end > p2.position.start) {
+          ok = false
+          val msg =
+            s"""overlapping quick fixes in ${source.file.file.getAbsolutePath}:
+               |
+               |add `${p1.newText}` at
+               |${codeOf(p1.position, source)}
+               |
+               |add `${p2.newText}` at
+               |${codeOf(p2.position, source)}""".stripMargin.trim
+          issueWarning(Message.Plain(p1.position, msg, WarningCategory.Other, "", Nil))
+        }
+        ok
+      }
+
+      def underlyingFile(source: SourceFile): Option[Path] = {
+        val fileClass = source.file.getClass.getName
+        val p = if (fileClass.endsWith("xsbt.ZincVirtualFile")) {
+          import scala.language.reflectiveCalls
+          val path = source.file.asInstanceOf[ {def underlying(): {def id(): String}}].underlying().id()
+          Some(Paths.get(path))
+        } else
+          Option(source.file.file).map(_.toPath)
+        val r = p.filter(Files.exists(_))
+        if (r.isEmpty)
+          issueWarning(Message.Plain(NoPosition, s"Failed to apply quick fixes, file does not exist: ${source.file}", WarningCategory.Other, "", Nil))
+        r
+      }
+
+      val encoding = Charset.forName(settings.encoding.value)
+
+      def insertEdits(sourceChars: Array[Char], edits: List[TextEdit], file: Path): Array[Byte] = {
+        val patchedChars = new Array[Char](sourceChars.length + edits.iterator.map(_.delta).sum)
+        @tailrec def loop(edits: List[TextEdit], inIdx: Int, outIdx: Int): Unit = {
+          def copy(upTo: Int): Int = {
+            val untouched = upTo - inIdx
+            System.arraycopy(sourceChars, inIdx, patchedChars, outIdx, untouched)
+            outIdx + untouched
+          }
+          edits match {
+            case e :: es =>
+              val outNew = copy(e.position.start)
+              e.newText.copyToArray(patchedChars, outNew)
+              loop(es, e.position.end, outNew + e.newText.length)
+            case _ =>
+              val outNew = copy(sourceChars.length)
+              if (outNew != patchedChars.length)
+                issueWarning(Message.Plain(NoPosition, s"Unexpected content length when applying quick fixes; verify the changes to ${file.toFile.getAbsolutePath}", WarningCategory.Other, "", Nil))
+          }
+        }
+
+        loop(edits, 0, 0)
+        new String(patchedChars).getBytes(encoding)
+      }
+
+      def apply(edits: mutable.Set[TextEdit]): Unit = {
+        for ((source, edits) <- edits.groupBy(_.position.source).view.mapValues(_.toList.sortBy(_.position.start))) {
+          if (checkNoOverlap(edits, source)) {
+            underlyingFile(source) foreach { file =>
+              val sourceChars = new String(Files.readAllBytes(file), encoding).toCharArray
+              try Files.write(file, insertEdits(sourceChars, edits, file))
+              catch {
+                case e: IOException =>
+                  issueWarning(Message.Plain(NoPosition, s"Failed to apply quick fixes to ${file.toFile.getAbsolutePath}\n${e.getMessage}", WarningCategory.Other, "", Nil))
+              }
+            }
+          }
+        }
+      }
+    }
   }
 }
 
@@ -532,7 +680,8 @@ object Reporting {
     }
 
     final case class MessagePattern(pattern: Regex) extends MessageFilter {
-      def matches(message: Message): Boolean = pattern.findFirstIn(message.msg).nonEmpty
+      def check(msg: String) = pattern.findFirstIn(msg).nonEmpty
+      def matches(message: Message): Boolean = check(message.msg)
     }
 
     final case class SitePattern(pattern: Regex) extends MessageFilter {
@@ -542,10 +691,11 @@ object Reporting {
     final case class SourcePattern(pattern: Regex) extends MessageFilter {
       private[this] val cache = mutable.Map.empty[SourceFile, Boolean]
 
-      def matches(message: Message): Boolean = cache.getOrElseUpdate(message.pos.source, {
-        val sourcePath = message.pos.source.file.canonicalPath.replace("\\", "/")
+      def check(pos: Position) = cache.getOrElseUpdate(pos.source, {
+        val sourcePath = pos.source.file.canonicalPath.replace("\\", "/")
         pattern.findFirstIn(sourcePath).nonEmpty
       })
+      def matches(message: Message): Boolean = check(message.pos)
     }
 
     final case class DeprecatedOrigin(pattern: Regex) extends MessageFilter {

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -251,11 +251,11 @@ self =>
     val syntaxErrors = new ListBuffer[(Int, String, List[CodeAction])]
     def showSyntaxErrors() =
       for ((offset, msg, actions) <- syntaxErrors)
-        reporter.error(o2p(offset), msg, actions)
+        runReporting.error(o2p(offset), msg, actions)
 
     override def syntaxError(offset: Offset, msg: String, actions: List[CodeAction]): Unit = {
       if (smartParsing) syntaxErrors += ((offset, msg, actions))
-      else reporter.error(o2p(offset), msg, actions)
+      else runReporting.error(o2p(offset), msg, actions)
     }
 
     override def incompleteInputError(msg: String, actions: List[CodeAction]): Unit = {

src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala

@@ -51,6 +51,21 @@ trait StandardScalaSettings { _: MutableSettings =>
   val nowarn =         BooleanSetting ("-nowarn", "Generate no warnings.") withAbbreviation "--no-warnings" withPostSetHook { s => if (s.value) maxwarns.value = 0 }
   val optimise:        BooleanSetting // depends on post hook which mutates other settings
   val print =          BooleanSetting ("-print", "Print program with Scala-specific features removed.") withAbbreviation "--print"
+  val quickfix =       MultiStringSetting(
+    "-quickfix",
+    "filters",
+    "Apply quick fixes provided by the compiler for warnings and errors to source files",
+    helpText = Some(
+      """Apply quick fixes provided by the compiler for warnings and errors to source files.
+        |Syntax: -quickfix:<filter>,...,<filter>
+        |
+        |<filter> syntax is the same as for configurable warnings, see `-Wconf:help`. Examples:
+        |  -quickfix:any                    apply all available quick fixes
+        |  -quickfix:msg=Auto-application   apply quick fixes where the message contains "Auto-application"
+        |
+        |Use `-Wconf:any:warning-verbose` to display applicable message filters with each warning.
+        |""".stripMargin),
+    prepend = true)
   val release =
     ChoiceSetting("-release", "release", "Compile for a version of the Java API and target class file.", AllTargetVersions, normalizeTarget(javaSpecVersion))
       .withPostSetHook { setting =>

src/reflect/scala/reflect/internal/util/CodeAction.scala

@@ -36,4 +36,6 @@ case class CodeAction(title: String, description: Option[String], edits: List[Te
  *  @groupname Common   Commonly used methods
  *  @group ReflectionAPI
  */
-case class TextEdit(position: Position, newText: String)
+case class TextEdit(position: Position, newText: String) {
+  def delta: Int = newText.length - (position.end - position.start)
+}

test/files/neg/auto-application.check

@@ -7,7 +7,7 @@ auto-application.scala:5: error: Int does not take parameters
 auto-application.scala:6: error: Int does not take parameters
   ("": Object).##()
                  ^
-auto-application.scala:9: warning: Auto-application to `()` is deprecated. Supply the empty argument list `()` explicitly to invoke method meth,
+auto-application.scala:9: warning: [quick fix available] Auto-application to `()` is deprecated. Supply the empty argument list `()` explicitly to invoke method meth,
 or remove the empty argument list from its definition (Java-defined methods are exempt).
 In Scala 3, an unapplied method like this will be eta-expanded into a function.
   meth // warn, auto-application (of nilary methods) is deprecated

test/files/neg/for-comprehension-old.check

@@ -1,25 +1,25 @@
-for-comprehension-old.scala:6: error: `val` keyword in for comprehension is unsupported: just remove `val`
+for-comprehension-old.scala:6: error: [quick fix available] `val` keyword in for comprehension is unsupported: just remove `val`
   for (val x <- 1 to 5 ; y = x) yield x+y       // fail
              ^
-for-comprehension-old.scala:7: error: `val` keyword in for comprehension is unsupported: just remove `val`
+for-comprehension-old.scala:7: error: [quick fix available] `val` keyword in for comprehension is unsupported: just remove `val`
   for (val x <- 1 to 5 ; val y = x) yield x+y   // fail
              ^
-for-comprehension-old.scala:11: error: `val` keyword in for comprehension is unsupported: just remove `val`
+for-comprehension-old.scala:11: error: [quick fix available] `val` keyword in for comprehension is unsupported: just remove `val`
   for (z <- 1 to 2 ; val x <- 1 to 5 ; y = x) yield x+y       // fail
                            ^
-for-comprehension-old.scala:12: error: `val` keyword in for comprehension is unsupported: just remove `val`
+for-comprehension-old.scala:12: error: [quick fix available] `val` keyword in for comprehension is unsupported: just remove `val`
   for (z <- 1 to 2 ; val x <- 1 to 5 ; val y = x) yield x+y   // fail
                            ^
-for-comprehension-old.scala:5: warning: `val` keyword in for comprehension is deprecated: instead, bind the value without `val`
+for-comprehension-old.scala:5: warning: [quick fix available] `val` keyword in for comprehension is deprecated: instead, bind the value without `val`
   for (x <- 1 to 5 ; val y = x) yield x+y       // fail
                            ^
-for-comprehension-old.scala:7: warning: `val` keyword in for comprehension is deprecated: instead, bind the value without `val`
+for-comprehension-old.scala:7: warning: [quick fix available] `val` keyword in for comprehension is deprecated: instead, bind the value without `val`
   for (val x <- 1 to 5 ; val y = x) yield x+y   // fail
                                ^
-for-comprehension-old.scala:10: warning: `val` keyword in for comprehension is deprecated: instead, bind the value without `val`
+for-comprehension-old.scala:10: warning: [quick fix available] `val` keyword in for comprehension is deprecated: instead, bind the value without `val`
   for (z <- 1 to 2 ; x <- 1 to 5 ; val y = x) yield x+y       // fail
                                          ^
-for-comprehension-old.scala:12: warning: `val` keyword in for comprehension is deprecated: instead, bind the value without `val`
+for-comprehension-old.scala:12: warning: [quick fix available] `val` keyword in for comprehension is deprecated: instead, bind the value without `val`
   for (z <- 1 to 2 ; val x <- 1 to 5 ; val y = x) yield x+y   // fail
                                              ^
 4 warnings