Spec: Apply the changes to operators.

[Cherry-picked d410376]

Author: sjrd

docs/_spec/01-lexical-syntax.md

@@ -164,7 +164,7 @@ Scala is a line-oriented language where statements may be terminated by semi-col
 A newline in a Scala source text is treated as the special token “nl” if the three following criteria are satisfied:
 
 1. The token immediately preceding the newline can terminate a statement.
-1. The token immediately following the newline can begin a statement.
+1. The token immediately following the newline can begin a statement and is not a _leading infix operator_.
 1. The token appears in a region where newlines are enabled.
 
 The tokens that can terminate a statement are: literals, identifiers and the following delimiters and reserved words:
@@ -185,6 +185,14 @@ with    yield    ,    .    ;    :    =    =>    <-    <:    <%
 A `case` token can begin a statement only if followed by a
 `class` or `object` token.
 
+A _leading infix operator_ is a symbolic identifier such as `+`, or `approx_==`, or an identifier in backticks that:
+
+- starts a new line, and
+- is not following a blank line, and
+- is followed by at least one whitespace character (including new lines) and a token that can start an expression.
+
+Furthermore, if the operator appears on its own line, the next line must have at least the same indentation width as the operator.
+
 Newlines are enabled in:
 
 1. all of a Scala source file, except for nested regions where newlines are disabled, and

docs/_spec/03-types.md

@@ -172,6 +172,8 @@ Type operators ending in a colon ‘:’ are right-associative; all other operat
 In a sequence of consecutive type infix operations ´t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, ... \, \mathit{op_n} \, t_n´, all operators ´\mathit{op}\_1, ..., \mathit{op}\_n´ must have the same associativity.
 If they are all left-associative, the sequence is interpreted as ´(... (t_0 \mathit{op_1} t_1) \mathit{op_2} ...) \mathit{op_n} t_n´, otherwise it is interpreted as ´t_0 \mathit{op_1} (t_1 \mathit{op_2} ( ... \mathit{op_n} t_n) ...)´.
 
+Under `-source:future`, if the type name is alphanumeric and the target type is not marked [`infix`](./05-classes-and-objects.html#infix), a deprecation warning is emitted.
+
 The type operators `|` and `&` are not really special.
 Nevertheless, unless shadowed, they resolve to [the fundamental type aliases `scala.|` and `scala.&`](./12-the-scala-standard-library.html#fundamental-type-aliases), which represent [union and intersection types](#union-and-intersection-types), respectively.
 

docs/_spec/04-basic-declarations-and-definitions.md

@@ -575,6 +575,9 @@ The scope of a type parameter includes the whole signature, including any of the
 
 A _value parameter clause_ ´\mathit{ps}´ consists of zero or more formal parameter bindings such as `´x´: ´T´` or `´x: T = e´`, which bind value parameters and associate them with their types.
 
+A unary operator must not have explicit parameter lists even if they are empty.
+A unary operator is a method named `"unary_´op´"` where ´op´ is one of `+`, `-`, `!`, or `~`.
+
 ### Default Arguments
 
 Each value parameter declaration may optionally define a default argument.

docs/_spec/05-classes-and-objects.md

@@ -310,6 +310,7 @@ LocalModifier     ::=  ‘abstract’
                     |  ‘sealed’
                     |  ‘implicit’
                     |  ‘lazy’
+                    |  ‘infix’
 AccessModifier    ::=  (‘private’ | ‘protected’) [AccessQualifier]
 AccessQualifier   ::=  ‘[’ (id | ‘this’) ‘]’
 ```
@@ -401,6 +402,31 @@ happen at all).
 Attempting to access a lazy value during its initialization might lead to looping behavior.
 If an exception is thrown during initialization, the value is considered uninitialized, and a later access will retry to evaluate its right hand side.
 
+### `infix`
+The `infix` modifier applies to method definitions and type definitions.
+It signals that the method or type is intended for use in infix position, even if it has an alphanumeric name.
+
+If a method overrides another, their `infix` annotations must agree. Either both are annotated with `infix`, or none of them are.
+
+The first non-receiver parameter list of an `infix` method must define exactly one parameter. Examples:
+
+```scala
+infix def op1(x: S): R             // ok
+infix def op2[T](x: T)(y: S): R    // ok
+infix def op3[T](x: T, y: S): R    // error: two parameters
+extension (x: A)
+  infix def op4(y: B): R          // ok
+  infix def op5(y1: B, y2: B): R  // error: two parameters
+```
+
+`infix` modifiers can also be given to type, trait or class definitions that have exactly two type parameters. An infix type like
+
+```scala
+infix type op[X, Y]
+```
+
+can be applied using infix syntax, i.e., `A op B`.
+
 ###### Example
 The following code illustrates the use of qualified private:
 
@@ -1211,4 +1237,4 @@ A correctly typed version would use an _explicit_, _invariant_ type parameter `
 ```scala
 enum View[-´T´]:
   case Refl[´R´](f: ´R´ => ´R´) extends View[´R´]
-```
+```

docs/_spec/06-expressions.md

@@ -547,6 +547,8 @@ This expression is then interpreted as ´e.\mathit{op}(e_1,...,e_n)´.
 A left-associative binary operation ´e_1;\mathit{op};e_2´ is interpreted as ´e_1.\mathit{op}(e_2)´. If ´\mathit{op}´ is right-associative and its parameter is passed by name, the same operation is interpreted as ´e_2.\mathit{op}(e_1)´.
 If ´\mathit{op}´ is right-associative and its parameter is passed by value, it is interpreted as `{ val ´x´=´e_1´; ´e_2´.´\mathit{op}´(´x\,´) }`, where ´x´ is a fresh name.
 
+Under `-source:future`, if the method name is alphanumeric and the target method is not marked [`infix`](./05-classes-and-objects.html#infix), a deprecation warning is emitted.
+
 ### Assignment Operators
 
 An _assignment operator_ is an operator symbol (syntax category `op` in [Identifiers](01-lexical-syntax.html#identifiers)) that ends in an equals character “`=`”, with the following exceptions: