Enable significant indentation inside braces.

Also: Make indentation opt in, controlled by -indent.

-indent is set as a default option when testing.

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -158,7 +158,7 @@ object Config {
   final val simplifyApplications = true
 
   /** Always assume -indent */
-  final val allowIndent = true
+  final val alwaysIndent = false
 
   /** If set, prints a trace of all symbol completions */
   final val showCompletions = false

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

@@ -708,9 +708,8 @@ object Parsers {
       val isOutermost = in.currentRegion.isOutermost
       val savedPending = pendingPatches
       def allBraces(r: Region): Boolean = r match {
-        case Outermost => true
-        case InBraces(outer) => allBraces(outer)
-        case _ => false
+        case r: InBraces => allBraces(r.enclosing)
+        case _ => r.isOutermost
       }
       var canRewrite = allBraces(in.currentRegion) && // test (1)
         !testChars(in.lastOffset - 3, " =>") // test(6)
@@ -1290,6 +1289,7 @@ object Parsers {
           }
           else { accept(TLARROW); typ() }
         }
+        else if (in.token == INDENT) enclosed(INDENT, typ())
         else infixType()
 
       in.token match {
@@ -2160,8 +2160,15 @@ object Parsers {
     def block(): Tree = {
       val stats = blockStatSeq()
       def isExpr(stat: Tree) = !(stat.isDef || stat.isInstanceOf[Import])
-      if (stats.nonEmpty && isExpr(stats.last)) Block(stats.init, stats.last)
-      else Block(stats, EmptyTree)
+      stats match {
+        case (stat : Block) :: Nil =>
+          stat // A typical case where this happens is creating a block around a region
+               // hat is already indented, e.g. something following a =>.
+        case _ :: stats1 if isExpr(stats.last) =>
+          Block(stats.init, stats.last)
+        case _ =>
+          Block(stats, EmptyTree)
+      }
     }
 
     /** Guard ::= if PostfixExpr

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

@@ -234,7 +234,7 @@ object Scanners {
     val newSyntax = ctx.settings.newSyntax.value
 
     val noindentSyntax = ctx.settings.noindent.value
-    val indentSyntax = Config.allowIndent || ctx.settings.indent.value || noindentSyntax && rewrite
+    val indentSyntax = Config.alwaysIndent || ctx.settings.indent.value || noindentSyntax && rewrite
     val rewriteToIndent = ctx.settings.indent.value && rewrite
     val rewriteNoIndent = noindentSyntax && rewrite
 
@@ -352,15 +352,16 @@ object Scanners {
       case LPAREN | LBRACKET =>
         currentRegion = InParens(lastToken, currentRegion)
       case LBRACE =>
-        currentRegion = InBraces(currentRegion)
+        currentRegion = InBraces(null, currentRegion)
       case RBRACE =>
         def dropBraces(): Unit = currentRegion match {
-          case Outermost =>
-          case InBraces(outer) =>
-            currentRegion = outer
+          case r: InBraces =>
+            currentRegion = r.enclosing
           case _ =>
-            currentRegion = currentRegion.enclosing
-            dropBraces()
+            if (!currentRegion.isOutermost) {
+              currentRegion = currentRegion.enclosing
+              dropBraces()
+            }
         }
         dropBraces()
       case RPAREN | RBRACKET =>
@@ -566,42 +567,44 @@ object Scanners {
       var newlineIsSeparating = false
       var lastWidth = IndentWidth.Zero
       var indentPrefix = EMPTY
+      val nextWidth = indentWidth(offset)
       currentRegion match {
-        case Outermost =>
-          if (indentSyntax) indentIsSignificant = true
-          newlineIsSeparating = true
         case r: Indented =>
-          indentIsSignificant = true
-          newlineIsSeparating = true
+          indentIsSignificant = indentSyntax
           lastWidth = r.width
+          newlineIsSeparating = lastWidth <= nextWidth
           indentPrefix = r.prefix
-        case _: InBraces =>
+        case r: InBraces =>
+          indentIsSignificant = indentSyntax
+          if (r.width == null) r.width = nextWidth
+          lastWidth = r.width
           newlineIsSeparating = true
+          indentPrefix = LBRACE
         case _ =>
       }
-      val nextWidth = indentWidth(offset)
       if (newlineIsSeparating &&
-          canEndStatTokens.contains(lastToken)&&
+          canEndStatTokens.contains(lastToken) &&
           canStartStatTokens.contains(token) &&
-          (!indentIsSignificant || lastWidth <= nextWidth) &&
           !isLeadingInfixOperator())
         insert(if (pastBlankLine) NEWLINES else NEWLINE, lineOffset)
       else if (indentIsSignificant) {
-        if (lastWidth < nextWidth ||
-            lastWidth == nextWidth && (lastToken == MATCH || lastToken == CATCH) && token == CASE) {
+        if (nextWidth < lastWidth
+            || nextWidth == lastWidth && (indentPrefix == MATCH || indentPrefix == CATCH) && token != CASE) {
+          currentRegion match {
+            case r: Indented if !r.isOutermost && !isLeadingInfixOperator() =>
+              currentRegion = r.enclosing
+              insert(OUTDENT, offset)
+              handleEndMarkers(nextWidth)
+            case _ =>
+          }
+        }
+        else if (lastWidth < nextWidth ||
+                 lastWidth == nextWidth && (lastToken == MATCH || lastToken == CATCH) && token == CASE) {
           if (canStartIndentTokens.contains(lastToken)) {
             currentRegion = Indented(nextWidth, Set(), lastToken, currentRegion)
             insert(INDENT, offset)
           }
         }
-        else if (nextWidth < lastWidth ||
-                 nextWidth == lastWidth && (indentPrefix == MATCH || indentPrefix == CATCH) && token != CASE) {
-          if (!isLeadingInfixOperator()) {
-            currentRegion = currentRegion.asInstanceOf[Indented].enclosing
-            insert(OUTDENT, offset)
-            handleEndMarkers(nextWidth)
-          }
-        }
         else if (lastWidth != nextWidth)
           errorButContinue(
             i"""Incompatible combinations of tabs and spaces in indentation prefixes.
@@ -661,9 +664,9 @@ object Scanners {
           val atEOL = isAfterLineEnd
           reset()
           if (atEOL) token = COLONEOL
-        case EOF =>
+        case EOF | RBRACE =>
           currentRegion match {
-            case r: Indented =>
+            case r: Indented if !r.isOutermost =>
               insert(OUTDENT, offset)
               currentRegion = r.outer
             case _ =>
@@ -1368,16 +1371,16 @@ object Scanners {
     def enclosing: Region = outer.asInstanceOf[Region]
   }
   case class InParens(prefix: Token, outer: Region) extends Region
-  case class InBraces(outer: Region) extends Region
+  case class InBraces(var width: IndentWidth | Null, outer: Region) extends Region
   case class InString(multiLine: Boolean, outer: Region) extends Region
 
   /** A class describing an indentation region.
    *  @param width   The principal indendation width
    *  @param others  Other indendation widths > width of lines in the same region
    */
-  case class Indented(width: IndentWidth, others: Set[IndentWidth], prefix: Token, outer: Region) extends Region
+  case class Indented(width: IndentWidth, others: Set[IndentWidth], prefix: Token, outer: Region | Null) extends Region
 
-  case object Outermost extends Region { val outer = null }
+  val Outermost = Indented(IndentWidth.Zero, Set(), EMPTY, null)
 
   enum IndentWidth {
     case Run(ch: Char, n: Int)

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -44,7 +44,7 @@ object TestConfiguration {
 
   val yCheckOptions = Array("-Ycheck:all")
 
-  val commonOptions = checkOptions ++ noCheckOptions ++ yCheckOptions
+  val commonOptions = Array("-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions
   val defaultOptions = TestFlags(basicClasspath, commonOptions)
   val withCompilerOptions =
     defaultOptions.withClasspath(withCompilerClasspath).withRunClasspath(withCompilerClasspath)