OUTDENT refactoring

Drop Indented region only after seeing an OUTDENT node. This aligns
region stack popping with the other closing tokens `]`, `)`, and `}`
and thereby allows to simplify `skip`.

Author: odersky

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

@@ -254,22 +254,16 @@ object Parsers {
      */
     protected def skip(): Unit =
       val lastRegion = in.currentRegion
-      var prevRegion = lastRegion
-        // the region before the last token
-        // we need to keep track of this since OUTDENT immediately pops
-        // the region whereas other closing tokens do that only when the
-        // next token is encountered.
       in.skipping = true
       def atStop =
         in.token == EOF
-        || skipStopTokens.contains(in.token) && (in.currentRegion eq lastRegion)
-        || in.token == OUTDENT && (prevRegion eq lastRegion) && in.indentWidth(in.offset) < in.lastKnownIndentWidth
-          // stop at OUTDENT if (1) currentRegion is the one that was just closed by the OUTDENT
-          // and (2) the new indentwidth is smaller than the indent width of currentRegion.
-          // The second condition corrects for the problem that sometimes we don't see an INDENT
+        || (in.currentRegion eq lastRegion)
+            && (skipStopTokens.contains(in.token)
+                || in.token == OUTDENT && in.indentWidth(in.offset) < in.lastKnownIndentWidth)
+          // stop at OUTDENT if the new indentwidth is smaller than the indent width of
+          // currentRegion. This corrects for the problem that sometimes we don't see an INDENT
           // when skipping and therefore might erroneously end up syncing on a nested OUTDENT.
       while !atStop do
-        prevRegion = in.currentRegion
         in.nextToken()
       in.recoverSepRegions()
       lastErrorOffset = in.offset

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

@@ -274,7 +274,7 @@ object Scanners {
     private val prev = newTokenData
 
     /** The current region. This is initially an Indented region with zero indentation width. */
-    var currentRegion: Region = Indented(IndentWidth.Zero, Set(), EMPTY, null)
+    var currentRegion: Region = Indented(IndentWidth.Zero, EMPTY, null)
 
     def lastKnownIndentWidth: IndentWidth =
       def recur(r: Region | Null): IndentWidth =
@@ -333,6 +333,10 @@ object Scanners {
           case InParens(prefix, outer) if prefix + 1 == lastToken => currentRegion = outer
           case _ =>
         }
+      case OUTDENT =>
+        currentRegion match
+          case r: Indented => currentRegion = r.enclosing
+          case _ =>
       case STRINGLIT =>
         currentRegion match {
           case InString(_, outer) => currentRegion = outer
@@ -441,8 +445,8 @@ object Scanners {
             || {
               r.outer match
                 case null => true
-                case Indented(outerWidth, others, _, _) =>
-                  outerWidth < nextWidth && !others.contains(nextWidth)
+                case ro @ Indented(outerWidth, _, _) =>
+                  outerWidth < nextWidth && !ro.otherIndentWidths.contains(nextWidth)
                 case outer =>
                   outer.indentWidth < nextWidth
             }
@@ -548,6 +552,15 @@ object Scanners {
       var lastWidth = IndentWidth.Zero
       var indentPrefix = EMPTY
       val nextWidth = indentWidth(offset)
+
+      // If nextWidth is an indentation level not yet seen by enclosing indentation
+      // region, invoke `handler`.
+      def handleNewIndentWidth(r: Region, handler: Indented => Unit): Unit = r match
+        case r @ Indented(curWidth, prefix, outer)
+        if curWidth < nextWidth && !r.otherIndentWidths.contains(nextWidth) && nextWidth != lastWidth =>
+          handler(r)
+        case _ =>
+
       currentRegion match
         case r: Indented =>
           indentIsSignificant = indentSyntax
@@ -576,32 +589,28 @@ object Scanners {
           else if !isLeadingInfixOperator(nextWidth) && !statCtdTokens.contains(lastToken) && lastToken != INDENT then
             currentRegion match
               case r: Indented =>
-                currentRegion = r.enclosing
                 insert(OUTDENT, offset)
+                if next.token != COLON then
+                  handleNewIndentWidth(r.enclosing, ir =>
+                    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: ${ir.width} and $lastWidth"""))
               case r: InBraces if !closingRegionTokens.contains(token) =>
                 report.warning("Line is indented too far to the left, or a `}` is missing", sourcePos())
               case _ =>
 
         else if lastWidth < nextWidth
              || lastWidth == nextWidth && (lastToken == MATCH || lastToken == CATCH) && token == CASE then
           if canStartIndentTokens.contains(lastToken) then
-            currentRegion = Indented(nextWidth, Set(), lastToken, currentRegion)
+            currentRegion = Indented(nextWidth, lastToken, currentRegion)
             insert(INDENT, offset)
           else if lastToken == SELFARROW then
             currentRegion.knownWidth = nextWidth
         else if (lastWidth != nextWidth)
           errorButContinue(spaceTabMismatchMsg(lastWidth, nextWidth))
-      currentRegion match
-        case Indented(curWidth, others, prefix, outer)
-        if curWidth < nextWidth && !others.contains(nextWidth) && nextWidth != lastWidth =>
-          if token == OUTDENT && next.token != COLON then
-            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 token != OUTDENT || next.token == COLON then
+        handleNewIndentWidth(currentRegion, _.otherIndentWidths += nextWidth)
     end handleNewLine
 
     def spaceTabMismatchMsg(lastWidth: IndentWidth, nextWidth: IndentWidth) =
@@ -621,7 +630,7 @@ object Scanners {
         val nextWidth = indentWidth(next.offset)
         val lastWidth = currentRegion.indentWidth
         if lastWidth < nextWidth then
-          currentRegion = Indented(nextWidth, Set(), COLONEOL, currentRegion)
+          currentRegion = Indented(nextWidth, COLONEOL, currentRegion)
           offset = next.offset
           token = INDENT
     end observeIndented
@@ -636,7 +645,6 @@ object Scanners {
          && !(token == CASE && r.prefix == MATCH)
          && next.token == EMPTY  // can be violated for ill-formed programs, e.g. neg/i12605.sala
       =>
-        currentRegion = r.enclosing
         insert(OUTDENT, offset)
       case _ =>
 
@@ -651,9 +659,7 @@ object Scanners {
     }
 
     def closeIndented() = currentRegion match
-      case r: Indented if !r.isOutermost =>
-        insert(OUTDENT, offset)
-        currentRegion = r.outer
+      case r: Indented if !r.isOutermost => insert(OUTDENT, offset)
       case _ =>
 
     /** - Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT
@@ -684,7 +690,6 @@ object Scanners {
           currentRegion match
             case r: Indented if isEnclosedInParens(r.outer) =>
               insert(OUTDENT, offset)
-              currentRegion = r.outer
             case _ =>
               lookAhead()
               if isAfterLineEnd
@@ -1570,13 +1575,16 @@ object Scanners {
 
   /** A class describing an indentation region.
    *  @param width   The principal indendation width
-   *  @param others  Other indendation widths > width of lines in the same region
    *  @param prefix  The token before the initial <indent> of the region
    */
-  case class Indented(width: IndentWidth, others: Set[IndentWidth], prefix: Token, outer: Region | Null) extends Region:
+  case class Indented(width: IndentWidth, prefix: Token, outer: Region | Null) extends Region:
     knownWidth = width
 
-  def topLevelRegion(width: IndentWidth) = Indented(width, Set(), EMPTY, null)
+    /** Other indendation widths > width of lines in the same region */
+    var otherIndentWidths: Set[IndentWidth] = Set()
+  end Indented
+
+  def topLevelRegion(width: IndentWidth) = Indented(width, EMPTY, null)
 
   enum IndentWidth {
     case Run(ch: Char, n: Int)

tests/neg/i12605.scala

@@ -1,3 +1,4 @@
 object Foo:
   def joe(): List[(Int, Int)] =
     List((2, 3), (3, 4)).filter case (a, b) => b > a // error // error
+// error

tests/neg/indent.scala

@@ -4,6 +4,6 @@ object Test {
   val y3 =
     if (1) max 10 gt 0  // error: end of statement expected but integer literal found // error // error
       1
-    else
+    else // error
       2
-} // error
+}