Make then optional at the end of line

`then` is treated like `;`: It is inferred at the end of a line, if

 - a new line would otherwise be inferred
 - the next line is indented

Disambiguation with Scala-2 syntax is as follows:

The question is whether to classify

   if (A) B
     C

as a condition A followed by a statement B (old-style), or
as a condition (A) B followed by a then part C, and an inferred
`then` in-between (new-style)

(new-style) is chosen if B cannot start a statement, or starts with a leading
infix operator. Otherwise put, (new-style) is chosen if in
```
(A)
B
```
no newline would be inserted. (old-style) is chosen otherwise.

This means that some otherwise legal conditions still need a `then` at the end of a line.
If (old-style) is eventually deprecated and removed, we can drop this restriction.

Author: odersky

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -220,7 +220,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       if (sym == NothingClass) RT_NOTHING
       else if (sym == NullClass) RT_NULL
       else {
-       val r = classBTypeFromSymbol(sym)
+        val r = classBTypeFromSymbol(sym)
         if (r.isNestedClass) innerClassBufferASM += r
         r
       }

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

@@ -69,7 +69,7 @@ object Parsers {
    *  if not, the AST will be supplemented.
    */
   def parser(source: SourceFile)(implicit ctx: Context): Parser =
-    if (source.isSelfContained) new ScriptParser(source)
+    if source.isSelfContained then new ScriptParser(source)
     else new Parser(source)
 
   abstract class ParserCommon(val source: SourceFile)(implicit ctx: Context) {
@@ -354,7 +354,7 @@ object Parsers {
           case NEWLINE | NEWLINES => in.nextToken()
           case SEMI => in.nextToken()
           case _ =>
-            syntaxError(i"end of statement expected but $in found")
+            syntaxError(i"end of statement expected but ${showToken(in.token)} found")
             in.nextToken() // needed to ensure progress; otherwise we might cycle forever
             accept(SEMI)
         }
@@ -813,20 +813,20 @@ object Parsers {
       else span
     }
 
-    /** Drop current token, which is assumed to be `then` or `do`. */
-    def dropTerminator(): Unit = {
-      var startOffset = in.offset
-      var endOffset = in.lastCharOffset
-      if (in.isAfterLineEnd) {
-        if (testChar(endOffset, ' '))
-          endOffset += 1
-      }
-      else
-        if (testChar(startOffset - 1, ' ') &&
-            !overlapsPatch(source, Span(startOffset - 1, endOffset)))
-          startOffset -= 1
-      patch(source, widenIfWholeLine(Span(startOffset, endOffset)), "")
-    }
+    /** Drop current token, if it is a `then` or `do`. */
+    def dropTerminator(): Unit =
+      if in.token == THEN || in.token == DO then
+        var startOffset = in.offset
+        var endOffset = in.lastCharOffset
+        if (in.isAfterLineEnd) {
+          if (testChar(endOffset, ' '))
+            endOffset += 1
+        }
+        else
+          if (testChar(startOffset - 1, ' ') &&
+              !overlapsPatch(source, Span(startOffset - 1, endOffset)))
+            startOffset -= 1
+        patch(source, widenIfWholeLine(Span(startOffset, endOffset)), "")
 
     /** rewrite code with (...) around the source code of `t` */
     def revertToParens(t: Tree): Unit =
@@ -841,7 +841,8 @@ object Parsers {
     /** In the tokens following the current one, does `query` precede any of the tokens that
      *   - must start a statement, or
      *   - separate two statements, or
-     *   - continue a statement (e.g. `else`, catch`)?
+     *   - continue a statement (e.g. `else`, catch`), or
+     *   - terminate the current scope?
      */
     def followedByToken(query: Token): Boolean = {
       val lookahead = in.LookaheadScanner()
@@ -1251,7 +1252,7 @@ object Parsers {
     }
 
     def possibleTemplateStart(): Unit = {
-      in.observeIndented(noIndentTemplateTokens, nme.derives)
+      in.observeIndented(unless = noIndentTemplateTokens, unlessSoftKW = nme.derives)
       newLineOptWhenFollowedBy(LBRACE)
     }
 
@@ -1650,35 +1651,51 @@ object Parsers {
 
 /* ----------- EXPRESSIONS ------------------------------------------------ */
 
+    /** Does the current conditional expression continue after
+     *  the initially parsed (...) region?
+     */
+    def toBeContinued(altToken: Token): Boolean =
+      if in.token == altToken || in.isNewLine || in.isScala2Mode then
+        false // a newline token means the expression is finished
+      else if !canStartStatTokens.contains(in.token)
+              || in.isLeadingInfixOperator(inConditional = true)
+      then
+        true
+      else
+        followedByToken(altToken) // scan ahead to see whether we find a `then` or `do`
+
     def condExpr(altToken: Token): Tree =
-      if (in.token == LPAREN) {
+      if in.token == LPAREN then
         var t: Tree = atSpan(in.offset) { Parens(inParens(exprInParens())) }
-        if (in.token != altToken && followedByToken(altToken))
-          t = inSepRegion(LPAREN, RPAREN) {
-            newLineOpt()
+        val newSyntax = toBeContinued(altToken)
+        if newSyntax then
+          t = inSepRegion(LBRACE, RBRACE) {
             expr1Rest(postfixExprRest(simpleExprRest(t)), Location.ElseWhere)
           }
-        if (in.token == altToken) {
-          if (rewriteToOldSyntax()) revertToParens(t)
+        if in.token == altToken then
+          if rewriteToOldSyntax() then revertToParens(t)
           in.nextToken()
-        }
-        else {
-          in.observeIndented(noIndentAfterConditionTokens)
+        else
+          if (altToken == THEN || !newSyntax) && in.isNewLine then
+            in.observeIndented()
+          if newSyntax && in.token != INDENT then accept(altToken)
           if (rewriteToNewSyntax(t.span))
             dropParensOrBraces(t.span.start, s"${tokenString(altToken)}")
-        }
         t
-      }
-      else {
+      else
         val t =
-          if (in.isNestedStart)
+          if in.isNestedStart then
             try expr() finally newLinesOpt()
           else
-            inSepRegion(LPAREN, RPAREN)(expr())
-        if (rewriteToOldSyntax(t.span.startPos)) revertToParens(t)
-        accept(altToken)
+            inSepRegion(LBRACE, RBRACE)(expr())
+        if rewriteToOldSyntax(t.span.startPos) then
+          revertToParens(t)
+        if altToken == THEN && in.isNewLine then
+          // don't require a `then` at the end of a line
+          in.observeIndented()
+        if in.token != INDENT then accept(altToken)
         t
-      }
+    end condExpr
 
     /** Expr              ::=  [`implicit'] FunParams =>' Expr
      *                      |  Expr1
@@ -2327,7 +2344,7 @@ object Parsers {
                 dropParensOrBraces(start, if (in.token == YIELD || in.token == DO) "" else "do")
               }
             }
-            in.observeIndented(noIndentAfterEnumeratorTokens)
+            in.observeIndented(unless = noIndentAfterEnumeratorTokens)
             res
           }
           else {

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

@@ -374,8 +374,8 @@ object Scanners {
       *  If a leading infix operator is found and -language:Scala2 or -old-syntax is set,
       *  emit a change warning.
       */
-    def isLeadingInfixOperator() = (
-          allowLeadingInfixOperators
+    def isLeadingInfixOperator(inConditional: Boolean = true) = (
+      allowLeadingInfixOperators
       && (  token == BACKQUOTED_IDENT
          || token == IDENTIFIER && isOperatorPart(name(name.length - 1)))
       && ch == ' '
@@ -388,9 +388,12 @@ object Scanners {
         canStartExpressionTokens.contains(lookahead.token)
       }
       && {
-        if (isScala2Mode || oldSyntax && !rewrite)
-          ctx.warning(em"""Line starts with an operator;
-                          |it is now treated as a continuation of the expression on the previous line,
+        if isScala2Mode || oldSyntax && !rewrite then
+          val (what, previous) =
+            if inConditional then ("Rest of line", "previous expression in parentheses")
+            else ("Line", "expression on the previous line")
+          ctx.warning(em"""$what starts with an operator;
+                          |it is now treated as a continuation of the $previous,
                           |not as a separate statement.""",
                       source.atSpan(Span(offset)))
         true
@@ -538,11 +541,13 @@ object Scanners {
          |Previous indent : $lastWidth
          |Latest indent   : $nextWidth"""
 
-    def observeIndented(unless: BitSet, unlessSoftKW: TermName = EmptyTermName): Unit =
+    def observeIndented(
+      unless: BitSet = BitSet.empty,
+      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 nextOffset = if (isNewLine) next.offset else offset
+        val nextToken = if (isNewLine) next.token else token
         val nextWidth = indentWidth(nextOffset)
         val lastWidth = currentRegion match {
           case r: Indented => r.width
@@ -554,7 +559,7 @@ object Scanners {
            && !unless.contains(nextToken)
            && (unlessSoftKW.isEmpty || token != IDENTIFIER || name != unlessSoftKW)) {
           currentRegion = Indented(nextWidth, Set(), COLONEOL, currentRegion)
-          if (!newLineInserted) next.copyFrom(this)
+          if (!isNewLine) next.copyFrom(this)
           offset = nextOffset
           token = INDENT
         }
@@ -880,38 +885,35 @@ object Scanners {
         print("la:")
         super.printState()
       }
-
-      /** Skip matching pairs of `(...)` or `[...]` parentheses.
-       *  @pre  The current token is `(` or `[`
-       */
-      final def skipParens(): Unit = {
-        val opening = token
-        nextToken()
-        while token != EOF && token != opening + 1 do
-          if token == opening then skipParens() else nextToken()
-        nextToken()
-      }
     }
 
+    /** Skip matching pairs of `(...)` or `[...]` parentheses.
+     *  @pre  The current token is `(` or `[`
+     */
+    final def skipParens(multiple: Boolean = true): Unit =
+      val opening = token
+      nextToken()
+      while token != EOF && token != opening + 1 do
+        if token == opening && multiple then skipParens() else nextToken()
+      nextToken()
+
     /** Is the token following the current one in `tokens`? */
     def lookaheadIn(tokens: BitSet): Boolean = {
       val lookahead = LookaheadScanner()
-      while ({
+      while
         lookahead.nextToken()
-        lookahead.token == NEWLINE || lookahead.token == NEWLINES
-      })
-      ()
+        lookahead.isNewLine
+      do ()
       tokens.contains(lookahead.token)
     }
 
     /** Is the current token in a position where a modifier is allowed? */
     def inModifierPosition(): Boolean = {
       val lookahead = LookaheadScanner()
-      while ({
+      while
         lookahead.nextToken()
-        lookahead.token == NEWLINE || lookahead.token == NEWLINES || lookahead.isSoftModifier
-      })
-      ()
+        lookahead.isNewLine || lookahead.isSoftModifier
+      do ()
       modifierFollowers.contains(lookahead.token)
     }
 
@@ -1003,6 +1005,8 @@ object Scanners {
     def isSoftModifierInParamModifierPosition: Boolean =
       isSoftModifier && !lookaheadIn(BitSet(COLON))
 
+    def isNewLine = token == NEWLINE || token == NEWLINES
+
     def isNestedStart = token == LBRACE || token == INDENT
     def isNestedEnd = token == RBRACE || token == OUTDENT
 
@@ -1273,7 +1277,8 @@ object Scanners {
 
     override def toString: String =
       showTokenDetailed(token) + {
-        if ((identifierTokens contains token) || (literalTokens contains token)) " " + name
+        if identifierTokens.contains(token) then name
+        else if literalTokens.contains(token) then strVal
         else ""
       }
 

language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala

@@ -66,7 +66,7 @@ class DottyLanguageServer extends LanguageServer
   private[this] var myDependentProjects: mutable.Map[ProjectConfig, mutable.Set[ProjectConfig]] = _
 
   def drivers: Map[ProjectConfig, InteractiveDriver] = thisServer.synchronized {
-    if (myDrivers == null) {
+    if myDrivers == null
       assert(rootUri != null, "`drivers` cannot be called before `initialize`")
       val configFile = new File(new URI(rootUri + '/' + IDE_CONFIG_FILE))
       val configs: List[ProjectConfig] = (new ObjectMapper).readValue(configFile, classOf[Array[ProjectConfig]]).toList
@@ -78,7 +78,7 @@ class DottyLanguageServer extends LanguageServer
         implicit class updateDeco(ss: List[String]) {
           def update(pathKind: String, pathInfo: String) = {
             val idx = ss.indexOf(pathKind)
-            val ss1 = if (idx >= 0) ss.take(idx) ++ ss.drop(idx + 2) else ss
+            val ss1 = if idx >= 0 then ss.take(idx) ++ ss.drop(idx + 2) else ss
             ss1 ++ List(pathKind, pathInfo)
           }
         }
@@ -91,7 +91,6 @@ class DottyLanguageServer extends LanguageServer
           "-scansource"
         myDrivers(config) = new InteractiveDriver(settings)
       }
-    }
     myDrivers
   }
 
@@ -105,12 +104,13 @@ class DottyLanguageServer extends LanguageServer
     System.gc()
     for ((_, driver, opened) <- driverConfigs; (uri, source) <- opened)
       driver.run(uri, source)
-    if (Memory.isCritical())
+    if Memory.isCritical()
       println(s"WARNING: Insufficient memory to run Scala language server on these projects.")
   }
 
   private def checkMemory() =
-    if (Memory.isCritical()) CompletableFutures.computeAsync { _ => restart() }
+    if Memory.isCritical()
+      CompletableFutures.computeAsync { _ => restart() }
 
   /** The configuration of the project that owns `uri`. */
   def configFor(uri: URI): ProjectConfig = thisServer.synchronized {
@@ -138,7 +138,7 @@ class DottyLanguageServer extends LanguageServer
     implicit class updateDeco(ss: List[String]) {
       def update(pathKind: String, pathInfo: String) = {
         val idx = ss.indexOf(pathKind)
-        val ss1 = if (idx >= 0) ss.take(idx) ++ ss.drop(idx + 2) else ss
+        val ss1 = if idx >= 0 then ss.take(idx) ++ ss.drop(idx + 2) else ss
         ss1 ++ List(pathKind, pathInfo)
       }
     }
@@ -151,7 +151,7 @@ class DottyLanguageServer extends LanguageServer
 
   /** A mapping from project `p` to the set of projects that transitively depend on `p`. */
   def dependentProjects: Map[ProjectConfig, Set[ProjectConfig]] = thisServer.synchronized {
-    if (myDependentProjects == null) {
+    if myDependentProjects == null
       val idToConfig = drivers.keys.map(k => k.id -> k).toMap
       val allProjects = drivers.keySet
 
@@ -165,7 +165,6 @@ class DottyLanguageServer extends LanguageServer
             dependency <- transitiveDependencies(project) } {
         myDependentProjects(dependency) += project
       }
-    }
     myDependentProjects
   }
 
@@ -195,7 +194,7 @@ class DottyLanguageServer extends LanguageServer
             throw ex
         }
       }
-      if (synchronize)
+      if synchronize
         thisServer.synchronized { computation() }
       else
         computation()
@@ -814,15 +813,15 @@ object DottyLanguageServer {
     def completionItemKind(sym: Symbol)(implicit ctx: Context): lsp4j.CompletionItemKind = {
       import lsp4j.{CompletionItemKind => CIK}
 
-      if (sym.is(Package) || sym.is(Module))
+      if sym.is(Package) || sym.is(Module)
         CIK.Module // No CompletionItemKind.Package (https://github.com/Microsoft/language-server-protocol/issues/155)
-      else if (sym.isConstructor)
+      else if sym.isConstructor
         CIK.Constructor
-      else if (sym.isClass)
+      else if sym.isClass
         CIK.Class
-      else if (sym.is(Mutable))
+      else if sym.is(Mutable)
         CIK.Variable
-      else if (sym.is(Method))
+      else if sym.is(Method)
         CIK.Method
       else
         CIK.Field
@@ -846,7 +845,8 @@ object DottyLanguageServer {
   }
 
   def markupContent(content: String): lsp4j.MarkupContent = {
-    if (content.isEmpty) null
+    if content.isEmpty
+      null
     else {
       val markup = new lsp4j.MarkupContent
       markup.setKind("markdown")