Revert "Disallow : after infix operators"

This reverts commit 0bd9739.

Change syntax and tests to allow `:` after operator. It turns out that the intent project of the CB
already uses them in a way that looks quite reasonable.

Author: odersky

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

@@ -934,6 +934,7 @@ object Parsers {
           val op = if (isType) typeIdent() else termIdent()
           val top1 = reduceStack(base, top, precedence(op.name), !op.name.isRightAssocOperatorName, op.name, isType)
           opStack = OpInfo(top1, op, in.offset) :: opStack
+          colonAtEOLOpt()
           newLineOptWhenFollowing(canStartOperand)
           if (maybePostfix && !canStartOperand(in.token)) {
             val topInfo = opStack.head
@@ -2160,6 +2161,7 @@ object Parsers {
     /** PostfixExpr   ::= InfixExpr [id [nl]]
      *  InfixExpr     ::= PrefixExpr
      *                  | InfixExpr id [nl] InfixExpr
+     *                  | InfixExpr id `:` IndentedExpr
      *                  | InfixExpr MatchClause
      */
     def postfixExpr(location: Location = Location.ElseWhere): Tree =
@@ -2203,8 +2205,9 @@ object Parsers {
      *                 |  SimpleExpr `.` MatchClause
      *                 |  SimpleExpr (TypeArgs | NamedTypeArgs)
      *                 |  SimpleExpr1 ArgumentExprs
-     *                 |  SimpleExpr1 :<<< (CaseClauses | Block) >>>                 -- under language.experimental.fewerBraces
-     *                 |  SimpleExpr1 FunParams (‘=>’ | ‘?=>’) indent Block outdent  -- under language.experimental.fewerBraces
+     *                 |  SimpleExpr1 `:` IndentedExpr                       -- under language.experimental.fewerBraces
+     *                 |  SimpleExpr1 FunParams (‘=>’ | ‘?=>’) IndentedExpr  -- under language.experimental.fewerBraces
+     *  IndentedExpr  ::=  indent (CaseClauses | Block) outdent
      *  Quoted        ::= ‘'’ ‘{’ Block ‘}’
      *                 |  ‘'’ ‘[’ Type ‘]’
      */
@@ -2304,8 +2307,7 @@ object Parsers {
         val arg = atSpan(start, in.skipToken()) {
           if in.token != INDENT then
             syntaxErrorOrIncomplete(i"indented expression expected, ${in} found")
-          val body = inDefScopeBraces(block(simplify = true))
-          Function(params, body)
+          Function(params, blockExpr())
         }
         Apply(t, arg)
       }
@@ -2397,8 +2399,7 @@ object Parsers {
       else fn
     }
 
-    /** BlockExpr         ::= `{' BlockExprContents `}'
-     *  BlockExprContents ::= CaseClauses | Block
+    /** BlockExpr     ::= <<< (CaseClauses | Block) >>>
      */
     def blockExpr(): Tree = atSpan(in.offset) {
       val simplify = in.token == INDENT

docs/docs/internals/syntax.md

@@ -227,6 +227,7 @@ Catches           ::=  ‘catch’ (Expr | ExprCaseClause)
 PostfixExpr       ::=  InfixExpr [id]                                           PostfixOp(expr, op)
 InfixExpr         ::=  PrefixExpr
                     |  InfixExpr id [nl] InfixExpr                              InfixOp(expr, op, expr)
+                    |  InfixExpr id ‘:’ IndentedExpr
                     |  InfixExpr MatchClause
 MatchClause       ::=  ‘match’ <<< CaseClauses >>>                              Match(expr, cases)
 PrefixExpr        ::=  [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr                       PrefixOp(expr, op)
@@ -244,10 +245,11 @@ SimpleExpr        ::=  SimpleRef
                     |  SimpleExpr ‘.’ MatchClause
                     |  SimpleExpr TypeArgs                                      TypeApply(expr, args)
                     |  SimpleExpr ArgumentExprs                                 Apply(expr, args)
-                    |  SimpleExpr1 :<<< (CaseClauses | Block) >>>               -- under language.experimental.fewerBraces
-                    |  SimpleExpr1 FunParams (‘=>’ | ‘?=>’) indent Block outdent -- under language.experimental.fewerBraces
+                    |  SimpleExpr1 ‘:’ IndentedExpr                             -- under language.experimental.fewerBraces
+                    |  SimpleExpr1 FunParams (‘=>’ | ‘?=>’) IndentedExpr        -- under language.experimental.fewerBraces
                     |  SimpleExpr ‘_’                                           PostfixOp(expr, _) (to be dropped)
                     |  XmlExpr													                        -- to be dropped
+IndentedExpr      ::=  indent CaseClauses | Block outdent
 Quoted            ::=  ‘'’ ‘{’ Block ‘}’
                     |  ‘'’ ‘[’ Type ‘]’
 ExprsInParens     ::=  ExprInParens {‘,’ ExprInParens}
@@ -257,7 +259,7 @@ ParArgumentExprs  ::=  ‘(’ [‘using’] ExprsInParens ‘)’
                     |  ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘*’ ‘)’              exprs :+ Typed(expr, Ident(wildcardStar))
 ArgumentExprs     ::=  ParArgumentExprs
                     |  BlockExpr
-BlockExpr         ::=  <<< (CaseClauses | Block) >>>
+BlockExpr         ::=  <<< CaseClauses | Block >>>
 Block             ::=  {BlockStat semi} [BlockResult]                           Block(stats, expr?)
 BlockStat         ::=  Import
                     |  {Annotation {nl}} {LocalModifier} Def

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

@@ -23,6 +23,16 @@ times(10):
    println("ha")
 ```
 
+The colon can also follow an infix operator:
+
+```scala
+credentials ++ :
+   val file = Path.userHome / ".credentials"
+   if file.exists
+   then Seq(Credentials(file))
+   else Seq()
+```
+
 Function calls that take multiple argument lists can also be handled this way:
 
 ```scala
@@ -39,7 +49,7 @@ val firstLine = files.get(fileName).fold:
 
 ## Lambda Arguments Without Braces
 
-Braces can also be omitted around multiple line function value arguments. Examples
+Braces can also be omitted around multiple line function value arguments:
 ```scala
 val xs = elems.map x =>
    val y = x - 1
@@ -52,26 +62,21 @@ Braces can be omitted if the lambda starts with a parameter list and `=>` or `=>
 ## Syntax Changes
 
 ```
-SimpleExpr  ::=  ...
-              |  SimpleExpr : indent (CaseClauses | Block) outdent
-              |  SimpleExpr FunParams (‘=>’ | ‘?=>’) indent Block outdent
+SimpleExpr       ::=  ...
+                   |  SimpleExpr `:` IndentedArgument
+                   |  SimpleExpr FunParams (‘=>’ | ‘?=>’) IndentedArgument
+InfixExpr        ::=  ...
+                   |  InfixExpr id `:` IndentedArgument
+IndentedArgument ::=  indent (CaseClauses | Block) outdent
 ```
 
-Note that indented blocks after `:` or `=>` only work when following a simple expression, they are not allowed after an infix operator. So the following examples
-would be incorrect:
-
-```scala
-   x + :      // error
-      y
-
-   f `andThen` y =>  // error
-      y + 1
-```
-
-Note also that a lambda argument must have the `=>` at the end of a line for braces
+Note that a lambda argument must have the `=>` at the end of a line for braces
 to be optional. For instance, the following would also be incorrect:
 
 ```scala
   xs.map x => x + 1   // error: braces or parentheses are required
+```
+The lambda has to be enclosed in braces or parentheses:
+```scala
   xs.map(x => x + 1)  // ok
 ```

tests/neg/indent-colons.scala

@@ -6,10 +6,3 @@ val x =
   else:  // error
     2
 
-
-val credentials = List("OK")
-val all = credentials ++ :  // error
-  val file = "file"  // error
-  if file.isEmpty    // error
-  then Seq("none")
-  else Seq(file)

tests/neg/indent-experimental.scala

@@ -139,3 +139,30 @@ val o =
   :
     x => x.toString
 
+object Test23:
+  val x = 1.+ :  // ok
+    2
+
+  val y = 1 + : // ok
+    2
+
+  val r = 1 to:
+    100
+
+  val credentials = List("OK")
+  val all = credentials ++ :
+    val file = "file"
+    if file.isEmpty
+    then Seq("none")
+    else Seq(file)
+
+extension (x: Boolean)
+  infix def or (y: => Boolean) = x || y
+
+def test24(x: Int, y: Int) =
+  x < y or:
+    x > y
+  or:
+    x == y
+
+