Use indentation to control newline insertion before parentheses

Scala currently uses an ad-hoc set of rules to determine whether a line
starting with an opening `(`, `[`, or `{` is an argument to the previous
line or starts a new statement. Specifically, a new line is always
inserted but is then skipped if the next token is a `{`. On the other
hand, lines starting with `[` and `(` always start a new statement.
This leads to the gotchas that
```
val x= foo
{ ... }
```
treats the braces of an argument to `foo`. A blank line is required to avoid this.
On the other hand,
```
foo(arg1)
  (arg2)
  (arg3)
```
does not work; the following lines are interpreted as separate statements.

In this PR, indentation is used instead to determine whether a following line starting
with `(`, `[`, ir `{` is an argument or a separate statement. In the first example, it
is a separate statement, since it is not indented. In the second example, it is treated
as an argument, since it is indented.

If we are past a blank line, we always assume the newline. For instance, this
example from Pouring.scala works:
```scala
  val moves =
    val glasses = 0 until capacity.length

	   (for g <- glasses yield Move.Empty(g))
    ++ (for g <- glasses yield Move.Fill(g))
    ++ (for g1 <- glasses; g2 <- glasses if g1 != g2 yield Move.Pour(g1, g2))
```
Without the blank line, the `(for g <- ...` expression would be treated as an additional
argument to `capacity.length`.

Author: odersky

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1054,10 +1054,9 @@ class TreeUnpickler(reader: TastyReader,
         ConstFold(untpd.Select(qual, name).withType(tpe))
       }
 
-      def readQualId(): (untpd.Ident, TypeRef) = {
+      def readQualId(): (untpd.Ident, TypeRef) =
         val qual = readTerm().asInstanceOf[untpd.Ident]
-         (untpd.Ident(qual.name).withSpan(qual.span), qual.tpe.asInstanceOf[TypeRef])
-      }
+        (untpd.Ident(qual.name).withSpan(qual.span), qual.tpe.asInstanceOf[TypeRef])
 
       def accessibleDenot(qualType: Type, name: Name, sig: Signature) = {
         val pre = ctx.typeAssigner.maybeSkolemizePrefix(qualType, name)

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

@@ -1278,11 +1278,6 @@ object Parsers {
       if (in.token == COLONEOL) in.nextToken()
     }
 
-    def possibleBracesStart(): Unit = {
-      colonAtEOLOpt()
-      newLineOptWhenFollowedBy(LBRACE)
-    }
-
     def possibleTemplateStart(isNew: Boolean = false): Unit =
       in.observeColonEOL()
       if in.token == COLONEOL then
@@ -1473,7 +1468,7 @@ object Parsers {
     val refinedType: () => Tree = () => refinedTypeRest(withType())
 
     def refinedTypeRest(t: Tree): Tree = {
-      possibleBracesStart()
+      colonAtEOLOpt()
       if (in.isNestedStart)
         refinedTypeRest(atSpan(startOffset(t)) { RefinedTypeTree(rejectWildcardType(t), refinement()) })
       else t
@@ -2227,7 +2222,7 @@ object Parsers {
     }
 
     def simpleExprRest(t: Tree, canApply: Boolean = true): Tree = {
-      if (canApply) possibleBracesStart()
+      if canApply then colonAtEOLOpt()
       in.token match {
         case DOT =>
           in.nextToken()
@@ -2303,7 +2298,7 @@ object Parsers {
     /** ArgumentExprss ::= {ArgumentExprs}
      */
     def argumentExprss(fn: Tree): Tree = {
-      possibleBracesStart()
+      colonAtEOLOpt()
       if (in.token == LPAREN || in.isNestedStart) argumentExprss(mkApply(fn, argumentExprs()))
       else fn
     }
@@ -3328,7 +3323,7 @@ object Parsers {
      */
     def selfInvocation(): Tree =
       atSpan(accept(THIS)) {
-        possibleBracesStart()
+        colonAtEOLOpt()
         argumentExprss(mkApply(Ident(nme.CONSTRUCTOR), argumentExprs()))
       }
 

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

@@ -409,7 +409,7 @@ object Scanners {
       *     and a token that can start an expression.
       *  If a leading infix operator is found and the source version is `3.0-migration`, emit a change warning.
       */
-    def isLeadingInfixOperator(inConditional: Boolean = true) = (
+    def isLeadingInfixOperator(inConditional: Boolean = true) =
       allowLeadingInfixOperators
       && (  token == BACKQUOTED_IDENT
          || token == IDENTIFIER && isOperatorPart(name(name.length - 1)))
@@ -434,7 +434,6 @@ object Scanners {
             sourcePos())
         true
       }
-    )
 
     /** The indentation width of the given offset */
     def indentWidth(offset: Offset): IndentWidth = {
@@ -533,6 +532,7 @@ object Scanners {
          && canEndStatTokens.contains(lastToken)
          && canStartStatTokens.contains(token)
          && !isLeadingInfixOperator()
+         && !(openParensTokens.contains(token) && lastWidth < nextWidth && !pastBlankLine)
       then
         insert(if (pastBlankLine) NEWLINES else NEWLINE, lineOffset)
         skipEndMarker(nextWidth)

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

@@ -221,8 +221,12 @@ object Tokens extends TokensCommon {
   final val atomicExprTokens: TokenSet = literalTokens | identifierTokens | BitSet(
     USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, QUOTEID, XMLSTART)
 
-  final val canStartExprTokens3: TokenSet = atomicExprTokens | BitSet(
-    LBRACE, LPAREN, LBRACKET, INDENT, QUOTE, IF, WHILE, FOR, NEW, TRY, THROW)
+  final val openParensTokens = BitSet(LBRACE, LPAREN, LBRACKET)
+
+  final val canStartExprTokens3: TokenSet =
+      atomicExprTokens
+    | openParensTokens
+    | BitSet(INDENT, QUOTE, IF, WHILE, FOR, NEW, TRY, THROW)
 
   final val canStartExprTokens2: TokenSet = canStartExprTokens3 | BitSet(DO)
 

tests/neg/i1707.scala

@@ -16,7 +16,7 @@ object DepBug {
     import d._
     a m (b)
   }
-  {   // error: Null does not take parameters (follow on)
+  {
     import dep._
     a m (b) // error: not found: a
   }

tests/pos/indented-parens.scala

@@ -0,0 +1,11 @@
+def f(x: Int)
+     (y: Int): Int = x + y
+
+
+@main def Test =
+  val x = f(1)
+    (2)
+    + f(1)
+       {2}
+  { println(x) }
+

tests/pos/path-from-class.scala

@@ -0,0 +1,18 @@
+// Paths rooted in outer classes. Not sure to what degree we
+// want to support them.
+class Outer {
+  type Bar
+  object inner {
+    type Foo
+    def foo: Foo = ???
+  }
+  def bar: Bar = ???
+}
+
+object Main {
+  val a = new Outer
+  val b = new Outer
+  def all = List(a.inner.foo, a.inner.foo)
+    // The inferred type is [Outer#inner.Foo], but this cannot be written in source
+  def bars: Outer # Bar = identity(a.bar)
+}

tests/pos/tailcall/t6891.scala

@@ -15,7 +15,7 @@ object O6891 {
     def beppy[C](c: => C) = {
       () => c
       @tailrec def loop(x: value.type): Unit = loop(x)
-        () => c
+      () => c
       ()
     }
   }

tests/run/Pouring.scala

@@ -18,7 +18,8 @@ class Pouring(capacity: Vector[Int]):
 
   val moves =
     val glasses = 0 until capacity.length
-       (for g <- glasses yield Move.Empty(g))
+    
+	   (for g <- glasses yield Move.Empty(g))
     ++ (for g <- glasses yield Move.Fill(g))
     ++ (for g1 <- glasses; g2 <- glasses if g1 != g2 yield Move.Pour(g1, g2))