More SepRegions refactorings

Make SepRegions a case class instead of a list of tokens. This is in preparation
of merging SepRegions and IndentRegions

Author: odersky

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

@@ -703,8 +703,12 @@ object Parsers {
       val (startOpening, endOpening) = startingElimRegion(colonRequired)
       val isOuterMost = in.sepRegions.isEmpty
       val savedPending = pendingPatches
-      var canRewrite =
-        in.sepRegions.forall(token => token == RBRACE || token == OUTDENT) && // test (1)
+      def allBraces(r: Region): Boolean = r match {
+        case GlobalRegion => true
+        case InBracesRegion(outer) => allBraces(outer)
+        case _ => false
+      }
+      var canRewrite = allBraces(in.sepRegions) && // test (1)
         !testChars(in.lastOffset - 3, " =>") // test(6)
       val t = enclosed(LBRACE, {
         canRewrite &= in.isAfterLineEnd // test (2)

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

@@ -305,7 +305,7 @@ object Scanners {
      *            (the STRINGLIT appears twice in succession on the stack iff the
      *             expression is a multiline string literal).
      */
-    var sepRegions: List[Token] = Nil
+    var sepRegions: Region = GlobalRegion
 
     /** Indentation widths, innermost to outermost */
     var indent: IndentRegion = IndentRegion(IndentWidth.Zero, Set(), EMPTY, null)
@@ -333,13 +333,15 @@ object Scanners {
     /** Are we directly in a string interpolation expression?
      */
     private def inStringInterpolation =
-      !sepRegions.isEmpty && sepRegions.head == STRINGLIT
+      sepRegions.isInstanceOf[InStringRegion]
 
     /** Are we directly in a multiline string interpolation expression?
      *  @pre inStringInterpolation
      */
-    private def inMultiLineInterpolation =
-      inStringInterpolation && !sepRegions.tail.isEmpty && sepRegions.tail.head == STRINGPART
+    private def inMultiLineInterpolation = sepRegions match {
+      case InStringRegion(_, multiLine) => multiLine
+      case _ => false
+    }
 
     /** read next token and return last offset
      */
@@ -350,24 +352,30 @@ object Scanners {
     }
 
     def adjustSepRegions(lastToken: Token): Unit = (lastToken: @switch) match {
-      case LPAREN =>
-        sepRegions = RPAREN :: sepRegions
-      case LBRACKET =>
-        sepRegions = RBRACKET :: sepRegions
+      case LPAREN | LBRACKET =>
+        sepRegions = InParensRegion(sepRegions, lastToken + 1)
       case LBRACE =>
-        sepRegions = RBRACE :: sepRegions
+        sepRegions = InBracesRegion(sepRegions)
       case RBRACE =>
-        while (!sepRegions.isEmpty && sepRegions.head != RBRACE)
-          sepRegions = sepRegions.tail
-        if (!sepRegions.isEmpty) sepRegions = sepRegions.tail
-      case RBRACKET | RPAREN =>
-        if (!sepRegions.isEmpty && sepRegions.head == lastToken)
-          sepRegions = sepRegions.tail
+        def dropBraces(): Unit = sepRegions match {
+          case GlobalRegion =>
+          case InBracesRegion(outer) =>
+            sepRegions = outer
+          case _ =>
+            sepRegions = sepRegions.outer
+            dropBraces()
+        }
+        dropBraces()
+      case RPAREN | RBRACKET =>
+        sepRegions match {
+          case InParensRegion(outer, closing) if closing == lastToken => sepRegions = outer
+          case _ =>
+        }
       case STRINGLIT =>
-        if (inMultiLineInterpolation)
-          sepRegions = sepRegions.tail.tail
-        else if (inStringInterpolation)
-          sepRegions = sepRegions.tail
+        sepRegions match {
+          case InStringRegion(outer, _) => sepRegions = outer
+          case _ =>
+        }
       case _ =>
     }
 
@@ -555,11 +563,10 @@ object Scanners {
      */
     def handleNewLine(lastToken: Token) = {
       val indentIsSignificant = indentSyntax && sepRegions.isEmpty
-      val newlineIsSeparating = (
-           sepRegions.isEmpty
-        || sepRegions.head == RBRACE
-        || sepRegions.head == ARROW && token == CASE
-       )
+      val newlineIsSeparating = sepRegions match {
+        case GlobalRegion | InBracesRegion(_) => true
+        case _ => false
+      }
       val curWidth = indentWidth(offset)
       val lastWidth = indent.width
       if (newlineIsSeparating &&
@@ -749,43 +756,39 @@ object Scanners {
         case '`' =>
           getBackquotedIdent()
         case '\"' =>
-          def fetchDoubleQuote() =
+          def stringPart(multiLine: Boolean) = {
+            getStringPart(multiLine)
+            sepRegions = InStringRegion(sepRegions, multiLine)
+          }
+          def fetchDoubleQuote() = {
             if (token == INTERPOLATIONID) {
               nextRawChar()
               if (ch == '\"') {
                 nextRawChar()
                 if (ch == '\"') {
                   nextRawChar()
-                  getStringPart(multiLine = true)
-                  sepRegions = STRINGPART :: sepRegions // indicate string part
-                  sepRegions = STRINGLIT :: sepRegions // once more to indicate multi line string part
-                }
-                else {
+                  stringPart(multiLine = true)
+                } else {
                   token = STRINGLIT
                   strVal = ""
                 }
-              }
-              else {
-                getStringPart(multiLine = false)
-                sepRegions = STRINGLIT :: sepRegions // indicate single line string part
-              }
-            }
-            else {
+              } else stringPart(multiLine = false)
+            } else {
               nextChar()
               if (ch == '\"') {
                 nextChar()
                 if (ch == '\"') {
                   nextRawChar()
                   getRawStringLit()
-                }
-                else {
+                } else {
                   token = STRINGLIT
                   strVal = ""
                 }
-              }
-              else
+              } else {
                 getStringLit()
+              }
             }
+          }
           fetchDoubleQuote()
         case '\'' =>
           def fetchSingleQuote() = {
@@ -1338,6 +1341,18 @@ object Scanners {
   }
   // end Scanner
 
+  abstract class Region {
+    def outer: Region
+    def isEmpty = false
+  }
+  case class InParensRegion(val outer: Region, closing: Token) extends Region
+  case class InBracesRegion(val outer: Region) extends Region
+  case class InStringRegion(val outer: Region, multiLine: Boolean) extends Region
+  case object GlobalRegion extends Region {
+    def outer = throw UnsupportedOperationException("GlobalRegion.outer")
+    override def isEmpty = true
+  }
+
   /** A class describing an indentation region.
    *  @param width   The principal indendation width
    *  @param others  Other indendation widths > width of lines in the same region

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

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