Syntax Change: Allow '.' in front of extension method

Allow

    def (c: Circle).circumference: Double

alongside

    def (c: Circle) circumference: Double

The syntax with '.' is preferred for normal methods, which have names
starting with a letter and which are not declared @infix. Right now,
this preference is not enforced.

Author: odersky

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

@@ -3105,7 +3105,7 @@ object Parsers {
      *            |  this ParamClause ParamClauses `=' ConstrExpr
      *  DefDcl  ::=  DefSig `:' Type
      *  DefSig  ::=  id [DefTypeParamClause] DefParamClauses
-     *            |  ExtParamClause [nl] id DefParamClauses
+     *            |  ExtParamClause [nl] [‘.’] id DefParamClauses
      */
     def defDefOrDcl(start: Offset, mods: Modifiers): Tree = atSpan(start, nameStart) {
       def scala2ProcedureSyntax(resultTypeStr: String) = {
@@ -3134,7 +3134,11 @@ object Parsers {
         makeConstructor(Nil, vparamss, rhs).withMods(mods).setComment(in.getDocComment(start))
       }
       else {
-        def extParamss() = try paramClause(0, prefix = true) :: Nil finally newLineOpt()
+        def extParamss() =
+          try paramClause(0, prefix = true) :: Nil
+          finally
+            if in.token == DOT then in.nextToken()
+            else newLineOpt()
         val (leadingTparams, leadingVparamss, flags) =
           if in.token == LBRACKET then
             (typeParamClause(ParamOwner.Def), extParamss(), Method | Extension)

docs/docs/contributing/debugging.md

@@ -88,7 +88,7 @@ But you can also do:
 assertPositioned(tree.reporting(s"Tree is: $result"))
 ```
 
-`def (a: A) reporting(f: given WrappedResult[T] => String, p: Printer = Printers.default): A` is defined on all types. The function `f` can be written without the argument since the argument is `given`. The `result` variable is a part of the `WrapperResult` – a tiny framework powering the `reporting` function. Basically, whenever you are using `reporting` on an object `A`, you can use the `result: A` variable from this function and it will be equal to the object you are calling `reporting` on.
+`def (a: A).reporting(f: given WrappedResult[T] => String, p: Printer = Printers.default): A` is defined on all types. The function `f` can be written without the argument since the argument is `given`. The `result` variable is a part of the `WrapperResult` – a tiny framework powering the `reporting` function. Basically, whenever you are using `reporting` on an object `A`, you can use the `result: A` variable from this function and it will be equal to the object you are calling `reporting` on.
 
 ## Printing out trees after phases
 To print out the trees you are compiling after the FrontEnd (scanner, parser, namer, typer) phases:

docs/docs/internals/syntax.md

@@ -358,7 +358,7 @@ ValDcl            ::=  ids ‘:’ Type
 VarDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 DefDcl            ::=  DefSig ‘:’ Type                                          DefDef(_, name, tparams, vparamss, tpe, EmptyTree)
 DefSig            ::=  id [DefTypeParamClause] DefParamClauses
-                    |  ExtParamClause [nl] id DefParamClauses
+                    |  ExtParamClause [nl] [‘.’] id DefParamClauses
 TypeDcl           ::=  id [TypeParamClause] SubtypeBounds [‘=’ Type]           TypeDefTree(_, name, tparams, bound
 
 Def               ::=  ‘val’ PatDef

docs/docs/reference/contextual/extension-methods.md

@@ -8,7 +8,7 @@ Extension methods allow one to add methods to a type after the type is defined.
 ```scala
 case class Circle(x: Double, y: Double, radius: Double)
 
-def (c: Circle) circumference: Double = c.radius * math.Pi * 2
+def (c: Circle).circumference: Double = c.radius * math.Pi * 2
 ```
 
 Like regular methods, extension methods can be invoked with infix `.`:
@@ -42,7 +42,7 @@ As an example, consider an extension method `longestStrings` on `Seq[String]` de
 
 ```scala
 trait StringSeqOps {
-  def (xs: Seq[String]) longestStrings = {
+  def (xs: Seq[String]).longestStrings = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
@@ -80,22 +80,26 @@ So `circle.circumference` translates to `CircleOps.circumference(circle)`, provi
 
 ### Operators
 
-The extension method syntax also applies to the definition of operators.
-In each case the definition syntax mirrors the way the operator is applied.
+The extension method syntax also applies to the definition of operators. 
+In this case it is allowed and preferable to omit the period between the leading parameter list
+and the operator. In each case the definition syntax mirrors the way the operator is applied.
 Examples:
 ```scala
 def (x: String) < (y: String) = ...
 def (x: Elem) +: (xs: Seq[Elem]) = ...
+def (x: Number) min (y: Number) = ...
 
 "ab" < "c"
 1 +: List(2, 3)
+x min 3
 ```
-The two definitions above translate to
+The three definitions above translate to
 ```scala
 def < (x: String)(y: String) = ...
 def +: (xs: Seq[Elem])(x: Elem) = ...
+def min(x: Number)(y: Number) = ...
 ```
-Note that swap of the two parameters `x` and `xs` when translating
+Note the swap of the two parameters `x` and `xs` when translating
 the right-binding operator `+:` to an extension method. This is analogous
 to the implementation of right binding operators as normal methods.
 
@@ -144,7 +148,7 @@ If a given extension is anonymous (as in the last clause), its name is synthesiz
 The extensions above are equivalent to the following regular given instances where the implemented parent is `AnyRef` and the parameters in the `extension` clause are repeated in each extension method definition:
 ```scala
 given stringOps: AnyRef {
-  def (xs: Seq[String]) longestStrings: Seq[String] = {
+  def (xs: Seq[String]).longestStrings: Seq[String] = {
     val maxLength = xs.map(_.length).max
     xs.filter(_.length == maxLength)
   }
@@ -165,7 +169,7 @@ Here are the syntax changes for extension methods and given extensions relative
 to the [current syntax](../../internals/syntax.md). `extension` is a soft keyword, recognized only after a `given`. It can be used as an identifier everywhere else.
 ```
 DefSig            ::=  ...
-                    |  ExtParamClause [nl] id DefParamClauses
+                    |  ExtParamClause [nl] [‘.’] id DefParamClauses
 GivenDef          ::=  ...
                        [id ‘:’] ‘extension’ ExtParamClause {GivenParamClause} ExtMethods
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’

docs/docs/reference/contextual/implicit-function-types.md

@@ -120,7 +120,7 @@ object PostConditions {
 
   def result[T](given r: WrappedResult[T]): T = r
 
-  def (x: T) ensuring[T](condition: (given WrappedResult[T]) => Boolean): T = {
+  def (x: T).ensuring[T](condition: (given WrappedResult[T]) => Boolean): T = {
     assert(condition(given x))
     x
   }

docs/docs/reference/contextual/relationship-implicits.md

@@ -104,7 +104,7 @@ will map to given clauses instead.
 
 Extension methods have no direct counterpart in Scala 2, but they can be simulated with implicit classes. For instance, the extension method
 ```scala
-def (c: Circle) circumference: Double = c.radius * math.Pi * 2
+def (c: Circle).circumference: Double = c.radius * math.Pi * 2
 ```
 could be simulated to some degree by
 ```scala

docs/docs/reference/contextual/typeclasses.md

@@ -11,7 +11,7 @@ with canonical implementations defined by given instances. Here are some example
 
 ```scala
 trait SemiGroup[T] with
-  def (x: T) combine (y: T): T
+  def (x: T).combine(y: T): T
 
 trait Monoid[T] extends SemiGroup[T] with
   def unit: T
@@ -20,11 +20,11 @@ object Monoid with
   def apply[T](given Monoid[T]) = summon[Monoid[T]]
 
 given Monoid[String] with
-  def (x: String) combine (y: String): String = x.concat(y)
+  def (x: String).combine(y: String): String = x.concat(y)
   def unit: String = ""
 
 given Monoid[Int] with
-  def (x: Int) combine (y: Int): Int = x + y
+  def (x: Int).combine(y: Int): Int = x + y
   def unit: Int = 0
 
 def sum[T: Monoid](xs: List[T]): T =

docs/docs/reference/dropped-features/package-objects.md

@@ -22,7 +22,7 @@ def b = a._2
 case class C()
 
 implicit object Cops {
-  def (x: C) pair (y: C) = (x, y)
+  def (x: C).pair(y: C) = (x, y)
 }
 ```
 There may be several source files in a package containing such toplevel definitions, and source files can freely mix toplevel value, method, and type definitions with classes and objects.

docs/docs/reference/metaprogramming/macros.md

@@ -707,7 +707,7 @@ This might be used to then perform an implicit search as in:
 
 
 ```scala
-inline def (sc: StringContext) showMe(args: =>Any*): String = ${ showMeExpr('sc, 'args) }
+inline def (sc: StringContext).showMe(args: =>Any*): String = ${ showMeExpr('sc, 'args) }
 
 private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(given qctx: QuoteContext): Expr[String] = {
   argsExpr match {

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

@@ -71,8 +71,8 @@ object Access {
 
   def (x: Permissions) & (y: Permissions): Permissions = x | y
   def (x: PermissionChoice) | (y: PermissionChoice): PermissionChoice = x | y
-  def (x: Permissions) is (y: Permissions) = (x & y) == y
-  def (x: Permissions) isOneOf (y: PermissionChoice) = (x & y) != 0
+  def (x: Permissions).is(y: Permissions) = (x & y) == y
+  def (x: Permissions).isOneOf(y: PermissionChoice) = (x & y) != 0
 
   val NoPermission: Permission = 0
   val ReadOnly: Permission = 1