Some renamings and re-orderings

Author: odersky

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

@@ -701,14 +701,14 @@ object Parsers {
     def bracesToIndented[T](body: => T): T = {
       val colonRequired = possibleColonOffset == in.lastOffset
       val (startOpening, endOpening) = startingElimRegion(colonRequired)
-      val isOuterMost = in.sepRegions.isEmpty
+      val isOutermost = in.currentRegion.isOutermost
       val savedPending = pendingPatches
       def allBraces(r: Region): Boolean = r match {
-        case GlobalRegion => true
-        case InBracesRegion(outer) => allBraces(outer)
+        case Outermost => true
+        case InBraces(outer) => allBraces(outer)
         case _ => false
       }
-      var canRewrite = allBraces(in.sepRegions) && // test (1)
+      var canRewrite = allBraces(in.currentRegion) && // test (1)
         !testChars(in.lastOffset - 3, " =>") // test(6)
       val t = enclosed(LBRACE, {
         canRewrite &= in.isAfterLineEnd // test (2)
@@ -730,7 +730,7 @@ object Parsers {
           patch(source, Span(startClosing, endClosing), "")
         }
         pendingPatches = applyPatch :: pendingPatches
-        if (isOuterMost) {
+        if (isOutermost) {
           pendingPatches.reverse.foreach(_())
           pendingPatches = Nil
         }

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

@@ -305,7 +305,12 @@ object Scanners {
      *            (the STRINGLIT appears twice in succession on the stack iff the
      *             expression is a multiline string literal).
      */
-    var sepRegions: Region = GlobalRegion
+    var currentRegion: Region = Outermost
+
+    def currentIndentWidth = currentRegion match {
+      case r: Indented => r.width
+      case _ => 0
+    }
 
     /** Indentation widths, innermost to outermost */
     var indent: IndentRegion = IndentRegion(IndentWidth.Zero, Set(), EMPTY, null)
@@ -330,16 +335,11 @@ object Scanners {
 
 // Get next token ------------------------------------------------------------
 
-    /** Are we directly in a string interpolation expression?
-     */
-    private def inStringInterpolation =
-      sepRegions.isInstanceOf[InStringRegion]
-
     /** Are we directly in a multiline string interpolation expression?
      *  @pre inStringInterpolation
      */
-    private def inMultiLineInterpolation = sepRegions match {
-      case InStringRegion(_, multiLine) => multiLine
+    private def inMultiLineInterpolation = currentRegion match {
+      case InString(multiLine, _) => multiLine
       case _ => false
     }
 
@@ -353,27 +353,27 @@ object Scanners {
 
     def adjustSepRegions(lastToken: Token): Unit = (lastToken: @switch) match {
       case LPAREN | LBRACKET =>
-        sepRegions = InParensRegion(sepRegions, lastToken + 1)
+        currentRegion = InParens(lastToken, currentRegion)
       case LBRACE =>
-        sepRegions = InBracesRegion(sepRegions)
+        currentRegion = InBraces(currentRegion)
       case RBRACE =>
-        def dropBraces(): Unit = sepRegions match {
-          case GlobalRegion =>
-          case InBracesRegion(outer) =>
-            sepRegions = outer
+        def dropBraces(): Unit = currentRegion match {
+          case Outermost =>
+          case InBraces(outer) =>
+            currentRegion = outer
           case _ =>
-            sepRegions = sepRegions.outer
+            currentRegion = currentRegion.enclosing
             dropBraces()
         }
         dropBraces()
       case RPAREN | RBRACKET =>
-        sepRegions match {
-          case InParensRegion(outer, closing) if closing == lastToken => sepRegions = outer
+        currentRegion match {
+          case InParens(prefix, outer) if prefix + 1 == lastToken => currentRegion = outer
           case _ =>
         }
       case STRINGLIT =>
-        sepRegions match {
-          case InStringRegion(outer, _) => sepRegions = outer
+        currentRegion match {
+          case InString(_, outer) => currentRegion = outer
           case _ =>
         }
       case _ =>
@@ -388,8 +388,11 @@ object Scanners {
       // Read a token or copy it from `next` tokenData
       if (next.token == EMPTY) {
         lastOffset = lastCharOffset
-        if (inStringInterpolation) fetchStringPart() else fetchToken()
-        if (token == ERROR) adjustSepRegions(STRINGLIT)
+        currentRegion match {
+          case InString(multiLine, _) => fetchStringPart(multiLine)
+          case _ => fetchToken()
+        }
+        if (token == ERROR) adjustSepRegions(STRINGLIT) // make sure we exit enclosing string literal
       }
       else {
         this.copyFrom(next)
@@ -511,14 +514,14 @@ object Scanners {
      *
      *  Indentation is _significant_ if indentSyntax is set, and we are not inside a
      *  {...}, [...], (...), case ... => pair, nor in a if/while condition
-     *  (i.e. sepRegions is empty).
+     *  (i.e. currentRegion is empty).
      *
      *  There are three rules:
      *
      *   1. Insert NEWLINE or NEWLINES if
      *
      *      - the closest enclosing sepRegion is { ... } or for ... do/yield,
-     *         or we are on the toplevel, i.e. sepRegions is empty, and
+     *         or we are on the toplevel, i.e. currentRegion is empty, and
      *      - the previous token can end a statement, and
      *      - the current token can start a statement, and
      *      - the current token is not a leading infix operator, and
@@ -562,9 +565,9 @@ object Scanners {
      *  if the current indentation width and the indentation of the current token are incomparable.
      */
     def handleNewLine(lastToken: Token) = {
-      val indentIsSignificant = indentSyntax && sepRegions.isEmpty
-      val newlineIsSeparating = sepRegions match {
-        case GlobalRegion | InBracesRegion(_) => true
+      val indentIsSignificant = indentSyntax && currentRegion.isOutermost
+      val newlineIsSeparating = currentRegion match {
+        case Outermost | InBraces(_) => true
         case _ => false
       }
       val curWidth = indentWidth(offset)
@@ -758,7 +761,7 @@ object Scanners {
         case '\"' =>
           def stringPart(multiLine: Boolean) = {
             getStringPart(multiLine)
-            sepRegions = InStringRegion(sepRegions, multiLine)
+            currentRegion = InString(multiLine, currentRegion)
           }
           def fetchDoubleQuote() = {
             if (token == INTERPOLATIONID) {
@@ -1129,9 +1132,9 @@ object Scanners {
       }
     }
 
-    private def fetchStringPart() = {
+    private def fetchStringPart(multiLine: Boolean) = {
       offset = charOffset - 1
-      getStringPart(multiLine = inMultiLineInterpolation)
+      getStringPart(multiLine)
     }
 
     private def isTripleQuote(): Boolean =
@@ -1342,16 +1345,15 @@ 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
+    def outer: Region | Null
+    def isOutermost = outer == null
+    def enclosing: Region = outer.asInstanceOf[Region]
   }
+  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

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(parser.in.sepRegions, parser.in.sepRegions = _) {
+      val res = saving(parser.in.currentRegion, parser.in.currentRegion = _) {
         val lbrace = parser.in.newTokenData
         lbrace.token = LBRACE
         lbrace.offset = parser.in.charOffset - 1