Refacto

Author: adpi2

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

@@ -562,15 +562,14 @@ object Parsers {
     def inBracesOrIndented[T](body: => T, inStatSeq: Boolean = false, rewriteWithColon: Boolean = false): T =
       val followsArrow = in.last.token == ARROW
       if in.token == INDENT then
-        val rewriteToBraces = in.rewriteNoIndent
-          && !followsArrow // braces are always optional after `=>` so none should be inserted
+        // braces are always optional after `=>` so none should be inserted
+        val rewriteToBraces = in.rewriteNoIndent && !followsArrow
         val rewriteToIndent = in.rewriteToIndent && !followsArrow
         if rewriteToBraces then indentedToBraces(body)
         else if rewriteToIndent then enclosed(INDENT, toIndentedRegion(body))
         else enclosed(INDENT, body)
       else
-        if in.rewriteToIndent then
-          bracesToIndented(body, inStatSeq, rewriteWithColon)
+        if in.rewriteToIndent then bracesToIndented(body, inStatSeq, rewriteWithColon)
         else inBraces(body)
 
     def inDefScopeBraces[T](body: => T, inStatSeq: Boolean = false, rewriteWithColon: Boolean = false): T =
@@ -642,10 +641,17 @@ object Parsers {
 
 /* -------- REWRITES ----------------------------------------------------------- */
 
-    /** 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
+    object IndentRewriteState:
+      /** 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
+
+      /** When rewriting to indent, the minimum indent width to rewrite to */
+      var minimumIndent: IndentWidth = IndentWidth.Zero
+
+      /** When rewritting to indent, the maximum indent width to rewrite to
+       * to ensure an indent region is properly closed by outdentation */
+      var maximumIndent: Option[IndentWidth] = None
 
     def testChar(idx: Int, p: Char => Boolean): Boolean = {
       val txt = source.content
@@ -735,7 +741,7 @@ object Parsers {
         else (start, end) // skip the end of line
       else (offset, end) // skip from last to end of token
 
-    /** Expand the current span to the surrounding blank lines */
+    /** Expand the current span to its surrounding blank space */
     def blankLinesAround(start: Offset, end: Offset): (Offset, Offset) =
       (skipBlanks(start - 1, -1) + 1, skipBlanks(end, 1))
 
@@ -756,7 +762,8 @@ object Parsers {
      *       false
      *     }
      */
-    def bracesToIndented[T](body: => T, inStatSeq: Boolean, rewriteWithColon: Boolean): T = {
+    def bracesToIndented[T](body: => T, inStatSeq: Boolean, rewriteWithColon: Boolean): T =
+      import IndentRewriteState.*
       val lastSaved = in.last.saveCopy
       val lastOffsetSaved = in.lastOffset
       val underColonSyntax = possibleColonOffset == in.lastOffset
@@ -770,13 +777,10 @@ object Parsers {
         lastSaved.token != RBRACE && // test (6)
         !(lastSaved.isOperator && lastSaved.isAfterLineEnd) && // test (7)
         !inStatSeq // test (8)
-      var innerIndent: Option[IndentWidth] = None
       val t = enclosed(LBRACE, {
         if in.isAfterLineEnd && in.token != RBRACE then // test (2)(4)
           toIndentedRegion:
-            try
-              innerIndent = Some(minimumIndent)
-              body
+            try body
             finally canRewrite &= in.isAfterLineEnd // test (3)
         else
           canRewrite = false
@@ -794,29 +798,22 @@ object Parsers {
           if lastSaved.isOperator then
             patch(Span(lastSaved.offset, lastSaved.offset + lastSaved.name.length), s"`${lastSaved.name}` :")
           else patch(Span(lastOffsetSaved), ":")
-        // force outdentation of token after }
-        maximumIndent = innerIndent
       else
         // no need to force outdentation after `}`
         maximumIndent = None
       t
-    }
-
-    /** When rewriting to indent, the minimum indent width to rewrite to */
-    var minimumIndent: IndentWidth = IndentWidth.Zero
-    /** When rewritting to indent, the maximum indent width to rewrite to
-     * to ensure an indent region is properly closed by outdentation */
-    var maximumIndent: Option[IndentWidth] = None
+    end bracesToIndented
 
     /** When rewriting to indent, make sure there is an indent after a `=>\n` */
-    def indentedRegionAfterArrow[T](body: => T, inCase: Boolean = false): T =
-      if in.rewriteToIndent && (inCase || in.isAfterLineEnd) then
+    def indentedRegionAfterArrow[T](body: => T, inCaseDef: Boolean = false): T =
+      if in.rewriteToIndent && (inCaseDef || in.isAfterLineEnd) then
         assert(in.last.isArrow || in.last.token == SELFARROW)
         toIndentedRegion(body)
       else body
 
     /** compute required indentation to indent region properly */
     def toIndentedRegion[T](body: => T): T =
+      import IndentRewriteState.*
       val enclosingIndent = minimumIndent
       minimumIndent =
         if enclosingIndent < in.currentRegion.indentWidth then
@@ -834,6 +831,7 @@ object Parsers {
     /** when rewriting to indent, check that indentaton is correct or patch */
     def patchIndent(): Unit =
       if in.isAfterLineEnd && !in.isNewLine && in.token != OUTDENT && in.token != INDENT then
+        import IndentRewriteState.*
         val currentIndent = in.indentWidth(in.offset)
         val indentEndOffset = in.lineOffset + currentIndent.size
         def isDotOrClosing = (closingParens + DOT).contains(in.token)
@@ -844,7 +842,8 @@ object Parsers {
         if needsOutdent || !(currentIndent >= minimumIndent) || offByOne then
           patch(Span(in.lineOffset, indentEndOffset), minimumIndent.toPrefix)
         // no need to outdent anymore
-        maximumIndent = None
+        if in.token != RBRACE then
+          maximumIndent = None
 
     def nextToken(): Unit =
       if in.rewriteToIndent then patchIndent()
@@ -1401,7 +1400,7 @@ object Parsers {
         syntaxErrorOrIncomplete(em"indented definitions expected, ${in} found")
 
     def colonAtEOLOpt(): Unit =
-      possibleColonOffset = in.lastOffset
+      IndentRewriteState.possibleColonOffset = in.lastOffset
       in.observeColonEOL(inTemplate = false)
       if in.token == COLONeol then
         nextToken()
@@ -2883,7 +2882,7 @@ object Parsers {
                           |an indented case.""")
             expr()
           else block()
-        }, inCase = true)
+        }, inCaseDef = true)
       })
     }
 
@@ -2901,7 +2900,7 @@ object Parsers {
         }
       }
       CaseDef(pat, EmptyTree, atSpan(accept(ARROW)) {
-        val t = indentedRegionAfterArrow(rejectWildcardType(typ()), inCase = true)
+        val t = indentedRegionAfterArrow(rejectWildcardType(typ()), inCaseDef = true)
         if in.token == SEMI then nextToken()
         newLinesOptWhenFollowedBy(CASE)
         t

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

@@ -1671,19 +1671,15 @@ object Scanners {
 
     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 = that <= this
 
-    def >(that: IndentWidth): Boolean = this >= that && !(that >= this)
+    def >(that: IndentWidth): Boolean = 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)**/
+    /** 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)

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

@@ -75,7 +75,7 @@ object Rewrites {
          .addPatch(span, replacement)
     )
 
-  /** Record a patch that replaces an inner patch */
+  /** Record a patch that replaces the first patch that it contains */
   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

tests/rewrites/indent-comments.check

@@ -1,4 +1,4 @@
-// Rewriting to indent should not remove the comments
+// Rewriting to indent should preserve comments
 class A: /* 1 */ /* 2 */
   def m1(b: Boolean) = /* 3 */ /* 4 */
     val x = if (b)

tests/rewrites/indent-comments.scala

@@ -1,4 +1,4 @@
-// Rewriting to indent should not remove the comments
+// Rewriting to indent should preserve comments
 class A /* 1 */ { /* 2 */
   def m1(b: Boolean) = /* 3 */ { /* 4 */
     val x = if (b)

tests/rewrites/indent-rewrite.check

@@ -1,4 +1,4 @@
-// A collection of patterns/bugs found when rewriting the community build to indent
+// A collection of patterns found when rewriting the community build to indent
 
 trait C1:
 

tests/rewrites/indent-rewrite.scala

@@ -1,4 +1,4 @@
-// A collection of patterns/bugs found when rewriting the community build to indent
+// A collection of patterns found when rewriting the community build to indent
 
 trait C1 {