Fixes for setting-controlled colon-at-eol

Author: odersky

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

@@ -717,7 +717,6 @@ object Parsers {
      */
     def bracesToIndented[T](body: => T): T = {
       val colonRequired = possibleColonOffset == in.lastOffset
-      if colonRequired && !in.colonSyntax then return body
       val (startOpening, endOpening) = startingElimRegion(colonRequired)
       val isOutermost = in.currentRegion.isOutermost
       def allBraces(r: Region): Boolean = r match {
@@ -736,7 +735,7 @@ object Parsers {
         }
       })
       canRewrite &= (in.isAfterLineEnd || statCtdTokens.contains(in.token)) // test (5)
-      if (canRewrite) {
+      if (canRewrite && (!colonRequired || in.colonSyntax)) {
         val openingPatchStr =
           if (!colonRequired) ""
           else if (testChar(startOpening - 1, Chars.isOperatorPart(_))) " :"
@@ -1219,7 +1218,7 @@ object Parsers {
     }
 
     def possibleTemplateStart(): Unit = {
-      in.observeIndented()
+      in.observeIndented(noIndentTemplateTokens, nme.derives)
       newLineOptWhenFollowedBy(LBRACE)
     }
 
@@ -1235,9 +1234,6 @@ object Parsers {
       case _ => op
     }
 
-    def observeIndentedUnlessFollowedBy(followers: BitSet): Unit =
-      if !followers.contains(in.token) then in.observeIndented()
-
 /* ------------- TYPES ------------------------------------------------------ */
 
     /** Same as [[typ]], but if this results in a wildcard it emits a syntax error and
@@ -1641,7 +1637,7 @@ object Parsers {
           in.nextToken()
         }
         else
-          observeIndentedUnlessFollowedBy(BitSet(THEN, DO))
+          in.observeIndented(noIndentAfterConditionTokens)
           if (rewriteToNewSyntax(t.span))
             dropParensOrBraces(t.span.start, s"${tokenString(altToken)}")
         t
@@ -2302,7 +2298,7 @@ object Parsers {
                 dropParensOrBraces(start, if (in.token == YIELD || in.token == DO) "" else "do")
               }
             }
-            observeIndentedUnlessFollowedBy(BitSet(YIELD, DO))
+            in.observeIndented(noIndentAfterEnumeratorTokens)
             res
           }
           else {
@@ -3547,11 +3543,10 @@ object Parsers {
     /** TemplateOpt = [Template]
      */
     def templateOpt(constr: DefDef): Template =
-      possibleBracesStart()
+      possibleTemplateStart()
       if (in.token == EXTENDS || isIdent(nme.derives))
         template(constr)
       else {
-        possibleTemplateStart()
         if (in.isNestedStart) template(constr)
         else Template(constr, Nil, Nil, EmptyValDef, Nil)
       }

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

@@ -535,23 +535,25 @@ object Scanners {
       }
     }
 
-    def observeIndented(): Unit =
+    def observeIndented(unless: BitSet, unlessSoftKW: TermName = EmptyTermName): Unit =
       if (indentSyntax && isAfterLineEnd && token != INDENT) {
         val newLineInserted = token == NEWLINE || token == NEWLINES
         val nextOffset = if (newLineInserted) next.offset else offset
+        val nextToken = if (newLineInserted) next.token else token
         val nextWidth = indentWidth(nextOffset)
         val lastWidth = currentRegion match {
           case r: Indented => r.width
           case r: InBraces => r.width
           case _ => nextWidth
         }
 
-        if (lastWidth < nextWidth) {
+        if lastWidth < nextWidth
+           && !unless.contains(nextToken)
+           && (unlessSoftKW.isEmpty || token != IDENTIFIER || name != unlessSoftKW) then
           currentRegion = Indented(nextWidth, Set(), COLONEOL, currentRegion)
           if (!newLineInserted) next.copyFrom(this)
           offset = nextOffset
           token = INDENT
-        }
       }
 
     /** - Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT, SEMI + ELSE => ELSE, COLON + <EOL> => COLONEOL

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

@@ -281,6 +281,10 @@ object Tokens extends TokensCommon {
    */
   final val startParamOrGivenTypeTokens: BitSet = startParamTokens | BitSet(GIVEN, ERASED)
 
+  final val noIndentTemplateTokens = BitSet(EXTENDS)
+  final val noIndentAfterConditionTokens = BitSet(THEN, DO)
+  final val noIndentAfterEnumeratorTokens = BitSet(YIELD, DO)
+
   final val scala3keywords = BitSet(ENUM, ERASED, GIVEN, IMPLIED)
 
   final val softModifierNames = Set(nme.inline, nme.opaque)

compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala

@@ -216,7 +216,7 @@ trait QuotesAndSplices {
           super.transform(tree)
         case tdef: TypeDef if tdef.symbol.hasAnnotation(defn.InternalQuoted_patternBindHoleAnnot) =>
           transformTypeBindingTypeDef(tdef, typePatBuf)
-         case tree @ AppliedTypeTree(tpt, args) =>
+        case tree @ AppliedTypeTree(tpt, args) =>
             val args1: List[Tree] = args.zipWithConserve(tpt.tpe.typeParams.map(_.paramVariance)) { (arg, v) =>
               arg.tpe match {
                 case _: TypeBounds => transform(arg)