Patch indentation with -indent -rewrite

Ensure indentation is correct when removing braces.

If the first indentation of the region is greater than the indentation
of the enclosing region, we use it to indent the whole region.
Otherwise we use the incremented indentation of the enclosing region.

```scala
  def foo = {
        x // we replicate indentation of x downward in region
    y
  }
```

```scala
  def foo = {
x // indentation of x is incorrect, we increment enclosing indentation
  y
  }
```

A bigger indentation than the required one is permitted except
just after a closing brace.

```scala
def bar = {
  x
    .toString // permitted indentation
  def foo = {
  }
    bar //  must be unindented, to not fall into the body of foo
}
```

Author: adpi2

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -483,7 +483,7 @@ object Scanners {
             if (nextChar == ch)
               recur(idx - 1, ch, n + 1, k)
             else {
-              val k1: IndentWidth => IndentWidth = if (n == 0) k else Conc(_, Run(ch, n))
+              val k1: IndentWidth => IndentWidth = if (n == 0) k else iw => k(Conc(iw, Run(ch, n)))
               recur(idx - 1, nextChar, 1, k1)
             }
           else recur(idx - 1, ' ', 0, identity)
@@ -523,7 +523,7 @@ object Scanners {
      *
      *      The following tokens can start an indentation region:
      *
-     *         :  =  =>  <-  if  then  else  while  do  try  catch  
+     *         :  =  =>  <-  if  then  else  while  do  try  catch
      *         finally  for  yield  match  throw  return  with
      *
      *      Inserting an INDENT starts a new indentation region with the indentation of the current
@@ -1266,6 +1266,7 @@ object Scanners {
               putChar(ch) ; nextRawChar()
               loopRest()
             else
+              next.lineOffset = if next.lastOffset < lineStartOffset then lineStartOffset else -1
               finishNamedToken(IDENTIFIER, target = next)
           end loopRest
           setStrVal()
@@ -1312,10 +1313,10 @@ object Scanners {
       }
     end getStringPart
 
-    private def fetchStringPart(multiLine: Boolean) = {
+    private def fetchStringPart(multiLine: Boolean) =
       offset = charOffset - 1
+      lineOffset = if lastOffset < lineStartOffset then lineStartOffset else -1
       getStringPart(multiLine)
-    }
 
     private def isTripleQuote(): Boolean =
       if (ch == '"') {
@@ -1657,21 +1658,35 @@ object Scanners {
     case Run(ch: Char, n: Int)
     case Conc(l: IndentWidth, r: Run)
 
-    def <= (that: IndentWidth): Boolean = this match {
-      case Run(ch1, n1) =>
-        that match {
-          case Run(ch2, n2) => n1 <= n2 && (ch1 == ch2 || n1 == 0)
-          case Conc(l, r) => this <= l
-        }
-      case Conc(l1, r1) =>
-        that match {
-          case Conc(l2, r2) => l1 == l2 && r1 <= r2
-          case _ => false
-        }
-    }
+    def <= (that: IndentWidth): Boolean = (this, that) match
+      case (Run(ch1, n1), Run(ch2, n2)) => n1 <= n2 && (ch1 == ch2 || n1 == 0)
+      case (Conc(l1, r1), Conc(l2, r2)) => (l1 == l2 && r1 <= r2) || this <= l2
+      case (_, Conc(l2, _)) => this <= l2
+      case _ => false
 
     def < (that: IndentWidth): Boolean = this <= that && !(that <= this)
 
+    def >= (that: IndentWidth): Boolean = (this, that) match
+      case (Run(ch1, n1), Run(ch2, n2)) => n1 >= n2 && (ch1 == ch2 || n2 == 0)
+      case (Conc(l1, r1), Conc(l2, r2)) => (l1 == l2 && r1 >= r2) || l1 >= that
+      case (Conc(l1, _), _) => l1 >= that
+      case _ => false
+
+    def >(that: IndentWidth): Boolean = this >= that && !(that >= this)
+
+    def size: Int = this match
+      case Run(_, n) => n
+      case Conc(l, r) => l.size + r.n
+
+    /** Add one level of indentation (one tab or two spaces depending on the last char)**/
+    def increment: IndentWidth =
+      def incRun(ch: Char, n: Int): Run = ch match
+        case ' ' => IndentWidth.Run(' ', n + 2)
+        case ch => IndentWidth.Run(ch, n + 1)
+      this match
+        case Run(ch, n) => incRun(ch, n)
+        case Conc(l, Run(ch, n)) => Conc(l, incRun(ch, n))
+
     /** Does `this` differ from `that` by not more than a single space? */
     def isClose(that: IndentWidth): Boolean = this match
       case Run(ch1, n1) =>

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -25,6 +25,10 @@ object Rewrites {
     def addPatch(span: Span, replacement: String): Unit =
       pbuf += Patch(span, replacement)
 
+    def patchOver(span: Span, replacement: String): Unit =
+      pbuf.indices.reverse.find(i => span.contains(pbuf(i).span)).foreach(pbuf.remove)
+      pbuf += Patch(span, replacement)
+
     def apply(cs: Array[Char]): Array[Char] = {
       val delta = pbuf.map(_.delta).sum
       val patches = pbuf.toList.sortBy(_.span.start)
@@ -71,6 +75,14 @@ object Rewrites {
          .addPatch(span, replacement)
     )
 
+  /** Record a patch that replaces an inner patch */
+  def patchOver(source: SourceFile, span: Span, replacement: String)(using Context): Unit =
+    if ctx.reporter != Reporter.NoReporter // NoReporter is used for syntax highlighting
+    then ctx.settings.rewrite.value.foreach(_.patched
+         .getOrElseUpdate(source, new Patches(source))
+         .patchOver(span, replacement)
+    )
+
   /** Patch position in `ctx.compilationUnit.source`. */
   def patch(span: Span, replacement: String)(using Context): Unit =
     patch(ctx.compilationUnit.source, span, replacement)

compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala

@@ -77,9 +77,14 @@ class CompilationTests {
       compileFile("tests/rewrites/rewrites3x.scala", defaultOptions.and("-rewrite", "-source", "future-migration")),
       compileFile("tests/rewrites/filtering-fors.scala", defaultOptions.and("-rewrite", "-source", "3.2-migration")),
       compileFile("tests/rewrites/refutable-pattern-bindings.scala", defaultOptions.and("-rewrite", "-source", "3.2-migration")),
-      compileFile("tests/rewrites/i8982.scala", defaultOptions.and("-indent", "-rewrite")),
-      compileFile("tests/rewrites/i9632.scala", defaultOptions.and("-indent", "-rewrite")),
-      compileFile("tests/rewrites/i11895.scala", defaultOptions.and("-indent", "-rewrite")),
+      compileFile("tests/rewrites/i8982.scala", indentRewrite),
+      compileFile("tests/rewrites/i9632.scala", indentRewrite),
+      compileFile("tests/rewrites/i11895.scala", indentRewrite),
+      compileFile("tests/rewrites/indent-rewrite.scala", indentRewrite),
+      compileFile("tests/rewrites/indent-comments.scala", indentRewrite),
+      compileFile("tests/rewrites/indent-mix-tab-space.scala", indentRewrite),
+      compileFile("tests/rewrites/indent-3-spaces.scala", indentRewrite),
+      compileFile("tests/rewrites/indent-mix-brace.scala", indentRewrite),
       compileFile("tests/rewrites/i12340.scala", unindentOptions.and("-rewrite")),
       compileFile("tests/rewrites/i17187.scala", unindentOptions.and("-rewrite")),
       compileFile("tests/rewrites/i17399.scala", unindentOptions.and("-rewrite")),

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -65,6 +65,7 @@ object TestConfiguration {
 
   val commonOptions = Array("-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions
   val defaultOptions = TestFlags(basicClasspath, commonOptions)
+  val indentRewrite = defaultOptions.and("-rewrite")
   val unindentOptions = TestFlags(basicClasspath, Array("-no-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions)
   val withCompilerOptions =
     defaultOptions.withClasspath(withCompilerClasspath).withRunClasspath(withCompilerClasspath)

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -0,0 +1,21 @@
+// Rewrite to indent, keeping 3 spaces as indentation
+
+def m1 =
+   def m2 =
+      "" +
+         "" +
+         ""
+   m2
+
+def m4 =
+   def m5 =
+      def m6 =
+         val x = ""
+         x
+            .apply(0)
+            .toString
+      m6
+         .toString
+   m5 +
+      m5
+         .toString

tests/rewrites/indent-3-spaces.check

@@ -0,0 +1,26 @@
+// Rewrite to indent, keeping 3 spaces as indentation
+
+def m1 = {
+   def m2 = {
+      "" +
+         "" +
+         ""
+   }
+   m2
+}
+
+def m4 = {
+   def m5 = {
+      def m6 = {
+         val x = ""
+         x
+            .apply(0)
+            .toString
+      }
+      m6
+         .toString
+   }
+   m5 +
+      m5
+         .toString
+}

tests/rewrites/indent-3-spaces.scala

@@ -0,0 +1,14 @@
+// Rewriting to indent should not remove the comments
+class A /** 1 */ : /** 2 */
+  def m1 = /** 3 */ /** 4 */
+    val x = if (true)
+    /** 5 */
+      "true"
+ /** 6 */
+    else
+ /** 7 */
+      "false"
+    /** 8 */
+    /** 9 */ x
+  /** 10 */ /** 11 */
+/** 12 */

tests/rewrites/indent-comments.check

@@ -0,0 +1,14 @@
+// Rewriting to indent should not remove the comments
+class A /** 1 */ { /** 2 */
+  def m1 = /** 3 */ { /** 4 */
+    val x = if (true)
+    /** 5 */ {
+      "true"
+    } /** 6 */
+    else
+    { /** 7 */
+      "false"
+    /** 8 */ }
+/** 9 */ x
+  /** 10 */ } /** 11 */
+/** 12 */ }

tests/rewrites/indent-comments.scala

@@ -0,0 +1,17 @@
+// A mix of nested in-brace regions and indented regions
+
+class A:
+  def m1 =
+    ""
+
+  def m2 =
+    def m3 =
+      val x = ""
+      x
+    m3
+
+class B:
+  def foo =
+    def bar =
+      ""
+    bar

tests/rewrites/indent-mix-brace.check

@@ -0,0 +1,21 @@
+// A mix of nested in-brace regions and indented regions
+
+class A:
+  def m1 = {
+    ""
+  }
+
+  def m2 = {
+def m3 =
+  val x = ""
+  x
+m3
+  }
+
+class B {
+  def foo =
+    def bar = {
+      ""
+    }
+    bar
+}

tests/rewrites/indent-mix-brace.scala

@@ -0,0 +1,22 @@
+// Contains an ugly but valid mix of spaces and tabs
+// Rewrite to significant indentation syntax
+
+def m1 =
+  def m2 =
+    "" +
+      "" +
+    	""
+  m2
+
+def m4 =
+  def m5 =
+  	def m6 =
+  		val x = ""
+  		x
+  		.apply(0)
+  		.toString
+  	m6
+  		.toString
+  m5 +
+  m5
+    	.toString

tests/rewrites/indent-mix-tab-space.check

@@ -0,0 +1,27 @@
+// Contains an ugly but valid mix of spaces and tabs
+// Rewrite to significant indentation syntax
+
+def m1 = {
+  def m2 = {
+    "" +
+      "" +
+    	""
+  }
+    m2
+}
+
+def m4 = {
+  def m5 = {
+  	def m6 = {
+	    val x = ""
+	  x
+	.apply(0)
+	    	.toString
+	}
+  	  m6
+  		.toString
+  }
+    m5 +
+  m5
+    	.toString
+}

tests/rewrites/indent-mix-tab-space.scala

@@ -0,0 +1,80 @@
+// A collection of patterns/bugs found when rewriting the community build to indent
+
+trait A:
+
+  class B
+// do not remove braces if empty region
+  class C {
+
+  }
+// do not remove braces if open brace is not followed by new line
+  def m1(x: Int) =
+  { x
+    .toString
+  }
+// add indent to pass an argument (fewer braces)
+  def m2: String =
+    m1:
+      5
+// indent inner method
+  def m3: Int =
+    def seq =
+      Seq(
+      "1",
+      "2"
+      )
+    seq
+    (1)
+    .toInt
+// indent refinement
+  def m4: Any:
+    def foo: String
+  =
+  new:
+    def foo: String =
+    """
+Hello, World!
+"""
+// indent end marker
+  end m4
+
+// do not indent if closing braces not followed by new line
+  def m5: String = {
+    val x = "Hi"
+    x
+  }; def m6(x: String): String =
+    s"""Bye $x ${
+      x
+    }
+do not indent in a multiline string"""
+  def m7 =
+    val foo = ""
+    val x = Seq(
+      s"${foo}",
+      ""
+    )
+
+  // preserve indentation style before 'case'
+  def m9(o: Option[String]) =
+    o match
+      case Some(x) => x
+      case None => ""
+
+    o match
+    case Some(x) => x
+    case None => ""
+
+  // preserve indent of chained calls
+  def m8(xs: Seq[String]) =
+    xs
+      .filter:
+        _ => true
+      .map(s => s * 2)
+
+  /** suround operators with backticks */
+  object `*:` :
+    def foo = ???
+  def *(x: String) = ???
+  def m9 =
+    `*` :
+      "foo"