Make IndentRegions a subcase of normal regions.

Nerge the `indented` and `currentRegion` stacks

Author: odersky

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

@@ -606,7 +606,11 @@ object Parsers {
 
     /** Parse indentation region `body` and rewrite it to be in braces instead */
     def indentedToBraces[T](body: => T): T = {
-      val indentWidth = in.indent.enclosing.width
+      val enclRegion = in.currentRegion.enclosing
+      def indentWidth = enclRegion match {
+        case Indented(w, _, _, _) => w
+        case _ => IndentWidth.Zero
+      }
       val followsColon = testChar(in.lastOffset - 1, ':')
       val startOpening =
         if (followsColon)
@@ -1172,7 +1176,7 @@ object Parsers {
     }
 
     def indentRegion[T](tag: EndMarkerTag)(op: => T): T = {
-      val iw = in.indent.width
+      val iw = in.currentIndentWidth
       val t = op
       in.consumeEndMarker(tag, iw)
       t

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

@@ -307,14 +307,11 @@ object Scanners {
      */
     var currentRegion: Region = Outermost
 
-    def currentIndentWidth = currentRegion match {
+    def currentIndentWidth: IndentWidth = currentRegion match {
       case r: Indented => r.width
-      case _ => 0
+      case _ => IndentWidth.Zero
     }
 
-    /** Indentation widths, innermost to outermost */
-    var indent: IndentRegion = IndentRegion(IndentWidth.Zero, Set(), EMPTY, null)
-
     /** The end marker that was skipped last */
     val endMarkers = new mutable.ListBuffer[EndMarker]
 
@@ -418,7 +415,7 @@ object Scanners {
      *  value at the end of the endMarkers queue.
      */
     private def handleEndMarkers(width: IndentWidth): Unit = {
-      if (next.token == IDENTIFIER && next.name == nme.end && width == indent.width) {
+      if (next.token == IDENTIFIER && next.name == nme.end && width == currentIndentWidth) {
         val lookahead = lookaheadScanner
         lookahead.nextToken() // skip the `end`
 
@@ -565,49 +562,63 @@ object Scanners {
      *  if the current indentation width and the indentation of the current token are incomparable.
      */
     def handleNewLine(lastToken: Token) = {
-      val indentIsSignificant = indentSyntax && currentRegion.isOutermost
-      val newlineIsSeparating = currentRegion match {
-        case Outermost | InBraces(_) => true
-        case _ => false
+      var indentIsSignificant = false
+      var newlineIsSeparating = false
+      var lastWidth = IndentWidth.Zero
+      var indentPrefix = EMPTY
+      currentRegion match {
+        case Outermost =>
+          if (indentSyntax) indentIsSignificant = true
+          newlineIsSeparating = true
+        case r: Indented =>
+          indentIsSignificant = true
+          newlineIsSeparating = true
+          lastWidth = r.width
+          indentPrefix = r.prefix
+        case _: InBraces =>
+          newlineIsSeparating = true
+        case _ =>
       }
-      val curWidth = indentWidth(offset)
-      val lastWidth = indent.width
+      val nextWidth = indentWidth(offset)
       if (newlineIsSeparating &&
           canEndStatTokens.contains(lastToken)&&
           canStartStatTokens.contains(token) &&
-          (!indentIsSignificant || lastWidth <= curWidth) &&
+          (!indentIsSignificant || lastWidth <= nextWidth) &&
           !isLeadingInfixOperator())
         insert(if (pastBlankLine) NEWLINES else NEWLINE, lineOffset)
       else if (indentIsSignificant) {
-        if (lastWidth < curWidth ||
-            lastWidth == curWidth && (lastToken == MATCH || lastToken == CATCH) && token == CASE) {
+        if (lastWidth < nextWidth ||
+            lastWidth == nextWidth && (lastToken == MATCH || lastToken == CATCH) && token == CASE) {
           if (canStartIndentTokens.contains(lastToken)) {
-            indent = IndentRegion(curWidth, Set(), lastToken, indent)
+            currentRegion = Indented(nextWidth, Set(), lastToken, currentRegion)
             insert(INDENT, offset)
           }
         }
-        else if (curWidth < lastWidth ||
-                 curWidth == lastWidth && (indent.token == MATCH || indent.token == CATCH) && token != CASE) {
+        else if (nextWidth < lastWidth ||
+                 nextWidth == lastWidth && (indentPrefix == MATCH || indentPrefix == CATCH) && token != CASE) {
           if (!isLeadingInfixOperator()) {
-            indent = indent.enclosing
+            currentRegion = currentRegion.asInstanceOf[Indented].enclosing
             insert(OUTDENT, offset)
-            handleEndMarkers(curWidth)
+            handleEndMarkers(nextWidth)
           }
         }
-        else if (lastWidth != curWidth)
+        else if (lastWidth != nextWidth)
           errorButContinue(
             i"""Incompatible combinations of tabs and spaces in indentation prefixes.
                 |Previous indent : $lastWidth
-                |Latest indent   : $curWidth""")
+                |Latest indent   : $nextWidth""")
+      }
+      currentRegion match {
+        case Indented(curWidth, others, prefix, outer) if curWidth < nextWidth && !others.contains(nextWidth) =>
+          if (token == OUTDENT)
+            errorButContinue(
+              i"""The start of this line does not match any of the previous indentation widths.
+                  |Indentation width of current line : $nextWidth
+                  |This falls between previous widths: $curWidth and $lastWidth""")
+          else
+            currentRegion = Indented(curWidth, others + nextWidth, prefix, outer)
+        case _ =>
       }
-      if (indentIsSignificant && indent.width < curWidth && !indent.others.contains(curWidth))
-        if (token == OUTDENT)
-          errorButContinue(
-            i"""The start of this line does not match any of the previous indentation widths.
-                |Indentation width of current line : $curWidth
-                |This falls between previous widths: ${indent.width} and $lastWidth""")
-        else
-          indent = IndentRegion(indent.width, indent.others + curWidth, indent.token, indent.outer)
     }
 
     /** - Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT, SEMI + ELSE => ELSE, COLON + <EOL> => COLONEOL
@@ -650,9 +661,13 @@ object Scanners {
           val atEOL = isAfterLineEnd
           reset()
           if (atEOL) token = COLONEOL
-        case EOF if !indent.isOutermost =>
-          insert(OUTDENT, offset)
-          indent = indent.outer
+        case EOF =>
+          currentRegion match {
+            case r: Indented =>
+              insert(OUTDENT, offset)
+              currentRegion = r.outer
+            case _ =>
+          }
         case _ =>
       }
     }
@@ -763,35 +778,38 @@ object Scanners {
             getStringPart(multiLine)
             currentRegion = InString(multiLine, currentRegion)
           }
-          def fetchDoubleQuote() = {
+          def fetchDoubleQuote() =
             if (token == INTERPOLATIONID) {
               nextRawChar()
               if (ch == '\"') {
                 nextRawChar()
                 if (ch == '\"') {
                   nextRawChar()
                   stringPart(multiLine = true)
-                } else {
+                }
+                else {
                   token = STRINGLIT
                   strVal = ""
                 }
-              } else stringPart(multiLine = false)
-            } else {
+              }
+              else stringPart(multiLine = false)
+            }
+            else {
               nextChar()
               if (ch == '\"') {
                 nextChar()
                 if (ch == '\"') {
                   nextRawChar()
                   getRawStringLit()
-                } else {
+                }
+                else {
                   token = STRINGLIT
                   strVal = ""
                 }
-              } else {
-                getStringLit()
               }
+              else
+                getStringLit()
             }
-          }
           fetchDoubleQuote()
         case '\'' =>
           def fetchSingleQuote() = {
@@ -1352,17 +1370,14 @@ object Scanners {
   case class InParens(prefix: Token, outer: Region) extends Region
   case class InBraces(outer: Region) extends Region
   case class InString(multiLine: Boolean, outer: Region) extends Region
-  case class Indented(width: IndentWidth, others: Set[IndentWidth], prefix: Token, outer: Region) extends Region
-  case object Outermost extends Region { val outer = null }
 
   /** A class describing an indentation region.
    *  @param width   The principal indendation width
    *  @param others  Other indendation widths > width of lines in the same region
    */
-  class IndentRegion(val width: IndentWidth, val others: Set[IndentWidth], val token: Token, val outer: IndentRegion | Null) {
-    def enclosing: IndentRegion = outer.asInstanceOf[IndentRegion]
-    def isOutermost = outer == null
-  }
+  case class Indented(width: IndentWidth, others: Set[IndentWidth], prefix: Token, outer: Region) extends Region
+
+  case object Outermost extends Region { val outer = null }
 
   enum IndentWidth {
     case Run(ch: Char, n: Int)