Make treatment of do language version dependent

`do` can start an expression or a statement only under -language:Scala2.
Maintaining this distinction is important in order not to insert spurious
newlines in front of `do` in a `while` or `for`.

Author: odersky

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

@@ -207,7 +207,7 @@ object Parsers {
     } && !in.isSoftModifierInModifierPosition
 
     def isExprIntro: Boolean =
-      canStartExpressionTokens.contains(in.token) && !in.isSoftModifierInModifierPosition
+      in.canStartExprTokens.contains(in.token) && !in.isSoftModifierInModifierPosition
 
     def isDefIntro(allowedMods: BitSet, excludedSoftModifiers: Set[TermName] = Set.empty): Boolean =
       in.token == AT ||
@@ -1655,11 +1655,13 @@ object Parsers {
       }
 
     /** A then part can start after `)` if the next token can start a statement
-     *  and is not a leading infix operator.
+     *  and is not a leading infix operator. In Scala-2 mode, a then part always
+     *  starts after `)`.
      */
     def canStartThenPart =
-      canStartStatTokens.contains(in.token)
-      && !in.isLeadingInfixOperator(inConditional = true)
+      in.isScala2Mode
+      || canStartStatTokens3.contains(in.token)
+         && !in.isLeadingInfixOperator(inConditional = true)
 
     /** Does the current conditional expression continue after
      *  the initially parsed (...) region?
@@ -1891,20 +1893,20 @@ object Parsers {
           }
         }
       case _ =>
-        if (isIdent(nme.inline) && !in.inModifierPosition() && in.lookaheadIn(canStartExpressionTokens)) {
+        if isIdent(nme.inline)
+           && !in.inModifierPosition()
+           && in.lookaheadIn(in.canStartExprTokens)
+        then
           val start = in.skipToken()
-          in.token match {
+          in.token match
             case IF =>
               ifExpr(start, InlineIf)
             case _ =>
               val t = postfixExpr()
               if (in.token == MATCH) matchExpr(t, start, InlineMatch)
-              else {
+              else
                 syntaxErrorOrIncomplete(i"`match` or `if` expected but ${in.token} found")
                 t
-              }
-          }
-        }
         else expr1Rest(postfixExpr(), location)
     }
 
@@ -2051,7 +2053,7 @@ object Parsers {
     def postfixExpr(): Tree = postfixExprRest(prefixExpr())
 
     def postfixExprRest(t: Tree): Tree =
-      infixOps(t, canStartExpressionTokens, prefixExpr, maybePostfix = true)
+      infixOps(t, in.canStartExprTokens, prefixExpr, maybePostfix = true)
 
     /** PrefixExpr   ::= [`-' | `+' | `~' | `!'] SimpleExpr
     */
@@ -2248,7 +2250,7 @@ object Parsers {
             lookahead.nextToken()
             lookahead.token != COLON
           }
-          else canStartExpressionTokens.contains(lookahead.token)
+          else in.canStartExprTokens.contains(lookahead.token)
         }
       }
       if (in.token == LPAREN && (!inClassConstrAnnots || isLegalAnnotArg))
@@ -2523,7 +2525,7 @@ object Parsers {
     /**  InfixPattern ::= SimplePattern {id [nl] SimplePattern}
      */
     def infixPattern(): Tree =
-      infixOps(simplePattern(), canStartExpressionTokens, simplePattern, isOperator = in.name != nme.raw.BAR)
+      infixOps(simplePattern(), in.canStartExprTokens, simplePattern, isOperator = in.name != nme.raw.BAR)
 
     /** SimplePattern    ::= PatVar
      *                    |  Literal

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

@@ -495,10 +495,11 @@ object Scanners {
           indentPrefix = LBRACE
         case _ =>
       }
-      if (newlineIsSeparating &&
-          canEndStatTokens.contains(lastToken) &&
-          canStartStatTokens.contains(token) &&
-          !isLeadingInfixOperator())
+      if newlineIsSeparating
+         && canEndStatTokens.contains(lastToken)
+         && canStartStatTokens.contains(token)
+         && !isLeadingInfixOperator()
+      then
         insert(if (pastBlankLine) NEWLINES else NEWLINE, lineOffset)
       else if indentIsSignificant then
         if nextWidth < lastWidth
@@ -1001,6 +1002,12 @@ object Scanners {
     def isNestedStart = token == LBRACE || token == INDENT
     def isNestedEnd = token == RBRACE || token == OUTDENT
 
+    def canStartStatTokens =
+      if isScala2Mode then canStartStatTokens2 else canStartStatTokens3
+
+    def canStartExprTokens =
+      if isScala2Mode then canStartExprTokens2 else canStartExprTokens3
+
 // Literals -----------------------------------------------------------------
 
     private def getStringLit() = {

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

@@ -219,8 +219,10 @@ object Tokens extends TokensCommon {
   final val atomicExprTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, QUOTEID, XMLSTART)
 
-  final val canStartExpressionTokens: TokenSet = atomicExprTokens | BitSet(
-    LBRACE, LPAREN, INDENT, QUOTE, IF, DO, WHILE, FOR, NEW, TRY, THROW)
+  final val canStartExprTokens3: TokenSet = atomicExprTokens | BitSet(
+    LBRACE, LPAREN, INDENT, QUOTE, IF, WHILE, FOR, NEW, TRY, THROW)
+
+  final val canStartExprTokens2: TokenSet = canStartExprTokens3 | BitSet(DO)
 
   final val canStartTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     THIS, SUPER, USCORE, LPAREN, AT)
@@ -247,7 +249,9 @@ object Tokens extends TokensCommon {
   /** Is token only legal as start of statement (eof also included)? */
   final val mustStartStatTokens: TokenSet = defIntroTokens | modifierTokens | BitSet(IMPORT, EXPORT, PACKAGE)
 
-  final val canStartStatTokens: TokenSet = canStartExpressionTokens | mustStartStatTokens | BitSet(
+  final val canStartStatTokens2: TokenSet = canStartExprTokens2 | mustStartStatTokens | BitSet(
+    AT, CASE)
+  final val canStartStatTokens3: TokenSet = canStartExprTokens3 | mustStartStatTokens | BitSet(
     AT, CASE)
 
   final val canEndStatTokens: TokenSet = atomicExprTokens | BitSet(
@@ -285,10 +289,6 @@ 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)
 
   final val softModifierNames = Set(nme.inline, nme.opaque)

compiler/src/dotty/tools/dotc/util/kwords.sc

@@ -13,6 +13,6 @@ object kwords {
                                                   //| atch, lazy, then, forSome, _, :, =, <-, =>, ';', ';', <:, >:, #, @, <%)
   keywords.toList.filter(kw => tokenString(kw) == null)
                                                   //> res1: List[Int] = List()
-    canStartStatTokens contains CASE              //> res2: Boolean = false
-                                                  
+  canStartStatTokens3 contains CASE               //> res2: Boolean = false
+
 }

tests/pos/indent4.scala

@@ -22,3 +22,14 @@ object testindent
     val y = x
     println(y)
 
+  while true
+  do println(1)
+
+  for i <- List(1, 2, 3)
+  do println(i)
+
+  while (true)
+  do println(1)
+
+  for (i <- List(1, 2, 3))
+  do println(i)