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

@@ -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)
@@ -701,10 +705,13 @@ 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
-      var canRewrite =
-        in.sepRegions.forall(token => token == RBRACE || token == OUTDENT) && // test (1)
+      def allBraces(r: Region): Boolean = r match {
+        case r: InBraces => allBraces(r.enclosing)
+        case _ => r.isOutermost
+      }
+      var canRewrite = allBraces(in.currentRegion) && // test (1)
         !testChars(in.lastOffset - 3, " =>") // test(6)
       val t = enclosed(LBRACE, {
         canRewrite &= in.isAfterLineEnd // test (2)
@@ -726,7 +733,7 @@ object Parsers {
           patch(source, Span(startClosing, endClosing), "")
         }
         pendingPatches = applyPatch :: pendingPatches
-        if (isOuterMost) {
+        if (isOutermost) {
           pendingPatches.reverse.foreach(_())
           pendingPatches = Nil
         }
@@ -1168,7 +1175,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
@@ -1282,6 +1289,7 @@ object Parsers {
           }
           else { accept(TLARROW); typ() }
         }
+        else if (in.token == INDENT) enclosed(INDENT, typ())
         else infixType()
 
       in.token match {
@@ -2152,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
@@ -2192,7 +2207,7 @@ object Parsers {
     /** Generator   ::=  [‘case’] Pattern `<-' Expr
      */
     def generator(): Tree = {
-      val casePat = if (in.token == CASE) { in.skipCASE(); true } else false
+      val casePat = if (in.token == CASE) { in.nextToken(); true } else false
       generatorRest(pattern1(), casePat)
     }
 
@@ -2302,15 +2317,21 @@ object Parsers {
     *  ImplicitCaseClause ::= ‘case’ PatVar [Ascription] [Guard] `=>' Block
     */
     val caseClause: () => CaseDef = () => atSpan(in.offset) {
-      accept(CASE)
-      CaseDef(pattern(), guard(), atSpan(accept(ARROW)) { block() })
+      val (pat, grd) = inSepRegion(LPAREN, RPAREN) {
+        accept(CASE)
+        (pattern(), guard())
+      }
+      CaseDef(pat, grd, atSpan(accept(ARROW)) { block() })
     }
 
     /** TypeCaseClause     ::= ‘case’ InfixType ‘=>’ Type [nl]
      */
     val typeCaseClause: () => CaseDef = () => atSpan(in.offset) {
-      accept(CASE)
-      CaseDef(infixType(), EmptyTree, atSpan(accept(ARROW)) {
+      val pat = inSepRegion(LPAREN, RPAREN) {
+        accept(CASE)
+        infixType()
+      }
+      CaseDef(pat, EmptyTree, atSpan(accept(ARROW)) {
         val t = typ()
         if (isStatSep) in.nextToken()
         t
@@ -3246,7 +3267,7 @@ object Parsers {
      */
     def enumCase(start: Offset, mods: Modifiers): DefTree = {
       val mods1 = mods | EnumCase
-      in.skipCASE()
+      accept(CASE)
 
       atSpan(start, nameStart) {
         val id = termIdent()