Patch indentation when removing braces (essentials)

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
}
```

And other bug fixes (see lampepfl#17522)

Author: adpi2

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

@@ -533,11 +533,11 @@ object Parsers:
     def inBrackets[T](body: => T): T = enclosed(LBRACKET, body)
 
     def inBracesOrIndented[T](body: => T, inStatSeq: Boolean = false, rewriteWithColon: Boolean = false): T =
-      val followsArrow = in.last.token == ARROW
       if in.token == INDENT then
         // braces are always optional after `=>` so none should be inserted
-        val rewriteToBraces = in.rewriteNoIndent && !followsArrow
-        val rewriteToIndent = in.rewriteToIndent && !followsArrow
+        val afterArrow = testChars(in.lastOffset - 3, " =>")
+        val rewriteToBraces = in.rewriteNoIndent && !afterArrow
+        val rewriteToIndent = in.rewriteToIndent && !afterArrow
         if rewriteToBraces then indentedToBraces(body)
         else if rewriteToIndent then enclosed(INDENT, toIndentedRegion(body))
         else enclosed(INDENT, body)
@@ -614,6 +614,11 @@ object Parsers:
 /* -------- REWRITES ----------------------------------------------------------- */
 
     object IndentRewriteState:
+      assert(in.rewriteToIndent)
+
+      /** A copy of the previous token */
+      var prev: TokenData = Scanners.newTokenData
+
       /** The last offset where a colon at the end of line would be required if a subsequent { ... }
        *  block would be converted to an indentation region. */
       var possibleColonOffset: Int = -1
@@ -705,8 +710,8 @@ object Parsers:
       val (start, end) = blankLinesAround(offset, offset + 1)
       if testChar(end, Chars.LF) then
         if testChar(start - 1, Chars.LF) then (start, end + 1) // skip the whole line
-        else (start, end) // skip the end of line
-      else (offset, end) // skip from last to end of token
+        else (start, end) // skip from previous char to end of line
+      else (offset, end) // skip from token to next char
 
     /** Expand the current span to its surrounding blank space */
     def blankLinesAround(start: Offset, end: Offset): (Offset, Offset) =
@@ -720,18 +725,18 @@ object Parsers:
      *   4. there is at least one token between the braces
      *   5. the closing brace is also at the end of the line, or it is followed by one of
      *      `then`, `else`, `do`, `catch`, `finally`, `yield`, or `match`.
-     *   6. the opening brace does not follow a closing `}`
+     *   6. the opening brace does not follow a closing brace
      *   7. last token is not a leading operator
      *   8. not a block in a sequence of statements
-     *   9. cannot rewrite to colon after a NEWLINE, e.g.
+     *   9. cannot rewrite if colon required after a NEWLINE, e.g.
      *     true ||
-     *     { // NEWLINE inserted between || and {
+     *     {
      *       false
      *     }
      */
     def bracesToIndented[T](body: => T, inStatSeq: Boolean, rewriteWithColon: Boolean): T =
       import IndentRewriteState.*
-      val lastSaved = in.last.saveCopy
+      val prevSaved = prev.saveCopy
       val lastOffsetSaved = in.lastOffset
       val underColonSyntax = possibleColonOffset == in.lastOffset
       val colonRequired = rewriteWithColon || underColonSyntax
@@ -741,9 +746,10 @@ object Parsers:
         case r: InBraces => true
         case _ => false
       var canRewrite = isBracesOrIndented(in.currentRegion) && // test (1)
-        lastSaved.token != RBRACE && // test (6)
-        !(lastSaved.isOperator && lastSaved.isAfterLineEnd) && // test (7)
-        !inStatSeq // test (8)
+        prevSaved.token != RBRACE && // test (6)
+        !(prevSaved.isOperator && prevSaved.isAfterLineEnd) && // test (7)
+        !inStatSeq && // test (8)
+        (!colonRequired || !in.isAfterLineEnd) // test (9)
       val t = enclosed(LBRACE, {
         if in.isAfterLineEnd && in.token != RBRACE then // test (2)(4)
           toIndentedRegion:
@@ -753,17 +759,16 @@ object Parsers:
           canRewrite = false
           body
       })
-      canRewrite &= (in.isAfterLineEnd || in.token == EOF || statCtdTokens.contains(in.token)) && // test (5)
-        (!colonRequired || !lastSaved.isNewLine) // test (9)
+      canRewrite &= (in.isAfterLineEnd || in.token == EOF || statCtdTokens.contains(in.token)) // test (5)
       if canRewrite && (!underColonSyntax || Feature.fewerBracesEnabled) then
-        val (startClosing, endClosing) = elimRegion(in.last.offset)
+        val (startClosing, endClosing) = elimRegion(in.lastOffset - 1)
         // patch over the added indentation to remove braces
         patchOver(source, Span(startOpening, endOpening), "")
         patchOver(source, Span(startClosing, endClosing), "")
         if colonRequired then
-          if lastSaved.token == IDENTIFIER && lastSaved.isOperator then
-            patch(Span(lastSaved.offset, lastSaved.offset + lastSaved.name.length), s"`${lastSaved.name}`:")
-          else if lastSaved.token == IDENTIFIER && lastSaved.name.last == '_' then
+          if prevSaved.token == IDENTIFIER && prevSaved.isOperator then
+            patch(Span(prevSaved.offset, lastOffsetSaved), s"`${prevSaved.name}`:")
+          else if prevSaved.token == IDENTIFIER && prevSaved.name.last == '_' then
             patch(Span(lastOffsetSaved), " :")
           else patch(Span(lastOffsetSaved), ":")
       else
@@ -816,7 +821,9 @@ object Parsers:
           maximumIndent = None
 
     def nextToken(): Unit =
-      if in.rewriteToIndent then patchIndent()
+      if in.rewriteToIndent then
+        IndentRewriteState.prev = in.saveCopy
+        patchIndent()
       in.nextToken()
 
     def skipToken(): Offset =
@@ -838,7 +845,7 @@ object Parsers:
       val preFill = if (closingStartsLine || endStr.isEmpty) "" else " "
       val postFill = if (in.lastOffset == in.offset) " " else ""
       val (startClosing, endClosing) =
-        if (closingStartsLine && endStr.isEmpty) elimRegion(in.last.offset)
+        if (closingStartsLine && endStr.isEmpty) elimRegion(in.lastOffset - 1)
         else (in.lastOffset - 1, in.lastOffset)
       patch(source, Span(startClosing, endClosing), s"$preFill$endStr$postFill")
 
@@ -1336,7 +1343,8 @@ object Parsers:
         syntaxErrorOrIncomplete(em"indented definitions expected, ${in} found")
 
     def colonAtEOLOpt(): Unit =
-      IndentRewriteState.possibleColonOffset = in.lastOffset
+      if in.rewriteToIndent then
+        IndentRewriteState.possibleColonOffset = in.lastOffset
       in.observeColonEOL(inTemplate = false)
       if in.token == COLONeol then
         nextToken()
@@ -2062,7 +2070,7 @@ object Parsers:
 
     def subExpr() = subPart(expr)
 
-    def expr(location: Location, inStatSeq: Boolean = false): Tree =
+    def expr(location: Location, inStatSeq: Boolean = false): Tree = {
       val start = in.offset
       in.token match
         case IMPLICIT =>
@@ -2385,7 +2393,7 @@ object Parsers:
      *  Quoted        ::= ‘'’ ‘{’ Block ‘}’
      *                 |  ‘'’ ‘[’ Type ‘]’
      */
-    def simpleExpr(location: Location, inStatSeq: Boolean = false): Tree =
+    def simpleExpr(location: Location, inStatSeq: Boolean = false): Tree = {
       var canApply = true
       val t = in.token match
         case XMLSTART =>
@@ -2557,12 +2565,13 @@ object Parsers:
 
     /** BlockExpr     ::= <<< (CaseClauses | Block) >>>
      */
-    def blockExpr(inStatSeq: Boolean = false): Tree = atSpan(in.offset):
+    def blockExpr(inStatSeq: Boolean = false): Tree = atSpan(in.offset) {
       val simplify = in.token == INDENT
       inDefScopeBraces({
         if (in.token == CASE) Match(EmptyTree, caseClauses(() => caseClause()))
         else block(simplify)
       }, inStatSeq = inStatSeq)
+    }
 
     /** Block ::= BlockStatSeq
      *  @note  Return tree does not have a defined span.
@@ -2731,7 +2740,7 @@ object Parsers:
             rejectWildcardType(infixType())
       CaseDef(pat, EmptyTree, atSpan(accept(ARROW)) {
         val t = indentedRegionAfterArrow(rejectWildcardType(typ()), inCaseDef = true)
-        if in.token == SEMI then nextToken()
+        if in.token == SEMI then in.nextToken()
         newLinesOptWhenFollowedBy(CASE)
         t
       })
@@ -4181,7 +4190,7 @@ object Parsers:
     def skipBracesHook(): Option[Tree] =
       if (in.token == XMLSTART) Some(xmlLiteral()) else None
 
-    override def blockExpr(inStatSeq: Boolean): Tree =
+    override def blockExpr(inStatSeq: Boolean): Tree = {
       skipBraces()
       EmptyTree
 

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

@@ -95,7 +95,7 @@ object Scanners:
 
   def newTokenData: TokenData = new TokenData {}
 
-  abstract class ScannerCommon(source: SourceFile)(using Context) extends CharArrayReader with TokenData:
+  abstract class ScannerCommon(source: SourceFile)(using Context) extends CharArrayReader with TokenData {
     val buf: Array[Char] = source.content
     def nextToken(): Unit
 
@@ -472,7 +472,7 @@ object Scanners:
           else if (nextChar == ' ' || nextChar == '\t')
             if (nextChar == ch)
               recur(idx - 1, ch, n + 1, k)
-            else
+            else {
               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)
@@ -744,6 +744,8 @@ object Scanners:
         if endMarkerTokens.contains(lookahead.token)
           && source.offsetToLine(lookahead.offset) == endLine
         then
+          if rewriteToIndent && lookahead.token == MATCH then
+            patch(Span(offset, offset + 3), "`end`")
           lookahead.nextToken()
           if lookahead.token == EOF
           || source.offsetToLine(lookahead.offset) > endLine

compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala

@@ -364,7 +364,7 @@ object MarkupParsers:
 
     def escapeToScala[A](op: => A, kind: String): A =
       xEmbeddedBlock = false
-      val res = saving(parser.in.currentRegion, parser.in.currentRegion = _):
+      val res = saving(parser.in.currentRegion, parser.in.currentRegion = _) {
         val lbrace = Scanners.newTokenData
         lbrace.token = LBRACE
         lbrace.offset = parser.in.charOffset - 1

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

@@ -28,7 +28,7 @@ object Rewrites:
       pbuf.indices.reverse.find(i => span.contains(pbuf(i).span)).foreach(pbuf.remove)
       pbuf += Patch(span, replacement)
 
-    def apply(cs: Array[Char]): Array[Char] =
+    def apply(cs: Array[Char]): Array[Char] = {
       val delta = pbuf.map(_.delta).sum
       val patches = pbuf.toList.sortBy(p => (p.span.start, p.span.end))
       if (patches.nonEmpty)