Allow infix operators on their own line

Author: odersky

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

@@ -345,14 +345,15 @@ object Scanners {
       allowLeadingInfixOperators
       && (  token == BACKQUOTED_IDENT
          || token == IDENTIFIER && isOperatorPart(name(name.length - 1)))
-      && ch == ' '
+      && ch <= ' '
       && !pastBlankLine
       && {
         val lookahead = LookaheadScanner()
         lookahead.allowLeadingInfixOperators = false
           // force a NEWLINE a after current token if it is on its own line
         lookahead.nextToken()
         canStartExprTokens.contains(lookahead.token)
+        || lookahead.token == NEWLINE && canStartExprTokens.contains(lookahead.next.token)
       }
       && {
         if migrateTo3 then

docs/docs/reference/changed-features/operators.md

@@ -114,7 +114,8 @@ val str = "hello"
 
 def condition =
    x > 0
-   || xs.exists(_ > 0)
+   ||
+   xs.exists(_ > 0)
    || xs.isEmpty
 ```
 Previously, those expressions would have been rejected, since the compiler's semicolon inference
@@ -124,8 +125,8 @@ To make this syntax work, the rules are modified to not infer semicolons in fron
 A _leading infix operator_ is
  - a symbolic identifier such as `+`, or `approx_==`, or an identifier in backticks,
  - that starts a new line,
- - that precedes a token on the same line that can start an expression,
- - and that is immediately followed by at least one space character `' '`.
+ - that precedes a token on the same or the next line that can start an expression,
+ - and that is immediately followed by at least one whitespace character.
 
 Example:
 

docs/docs/reference/other-new-features/indentation.md

@@ -159,18 +159,17 @@ Indentation prefixes can consist of spaces and/or tabs. Indentation widths are t
 
 ### Indentation and Braces
 
-Indentation can be mixed freely with braces and parentheses. For interpreting indentation inside braces and parentheses, the following rules apply.
+Indentation can be mixed freely with braces `{...}`, as well as brackets `[...]` and parentheses `(...)`. For interpreting indentation inside such regions, the following rules apply.
 
  1. The assumed indentation width of a multiline region enclosed in braces is the
     indentation width of the first token that starts a new line after the opening brace.
 
- 2. The assumed indentation width of a multiline region inside parentheses is:
+ 2. The assumed indentation width of a multiline region inside brackets or parentheses is:
 
-     - if the opening parenthesis is at the end of a line, the indentation width of token following it,
+     - if the opening bracket or parenthesis is at the end of a line, the indentation width of token following it,
      - otherwise, the indentation width of the enclosing region.
 
- 3. On encountering a closing brace `}` or parenthesis `)`, as many `<outdent>` tokens as necessary are
-    inserted to close all open indentation regions inside the pair of braces or parentheses.
+ 3. On encountering a closing brace `}`, bracket `]` or parenthesis `)`, as many `<outdent>` tokens as necessary are inserted to close all open nested indentation regions.
 
 For instance, consider:
 ```scala
@@ -190,8 +189,7 @@ statement starting with `val`).
    parenthesis is not at the end of a line.
  - The indentation width of the region in parentheses around `y + 1` is 9
    (i.e. the indentation width of `y + 1`).
- - Finally, the indentation width of the last region in parentheses starting with `(x` is 6 (i.e. the indentation
-width of the indented region following the `=>`.
+ - Finally, the indentation width of the last region in parentheses starting with `(x` is 6 (i.e. the indentation width of the indented region following the `=>`.
 
 ### Special Treatment of Case Clauses
 

tests/pos/leading-infix-op.scala

@@ -0,0 +1,13 @@
+def f(x: Int): Boolean =
+  x < 0
+  ||
+  x > 0
+  &&
+  x != 3
+
+def g(x: Option[Int]) = x match
+  case Some(err) =>
+    println("hi")
+    ???
+  case None =>
+    ???

tests/run/i7031.scala

@@ -1,9 +1,10 @@
 @main def Test = {
   val a = 5
   val x = 1
+
     + //
     `a` * 6
 
-  assert(x == 1)
+  assert(x == 1, x)
 }