Refine encoding of right-associative extension methods

Leading using clauses now scope over both left and right parameter.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -883,7 +883,9 @@ object desugar {
                 ext.vparamss ::: vparamss1
               vparams1 match
                 case vparam :: Nil =>
-                  if !vparam.mods.is(Given) then vparams1 :: ext.vparamss ::: vparamss1
+                  if !vparam.mods.is(Given) then
+                    val (leadingUsing, otherExtParamss) = ext.vparamss.span(isUsingClause)
+                    leadingUsing ::: vparams1 :: otherExtParamss ::: vparamss1
                   else badRightAssoc("cannot start with using clause")
                 case _ =>
                   badRightAssoc("must start with a single parameter")

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -794,29 +794,34 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
     import untpd._
-
-    def splitParams(paramss: List[List[ValDef]]): (List[List[ValDef]], List[List[ValDef]]) =
-      paramss match
-        case params1 :: (rest @ (_ :: _)) if tree.name.isRightAssocOperatorName =>
-          val (leading, trailing) = splitParams(rest)
-          (leading, params1 :: trailing)
-        case _ =>
-          val trailing = paramss
-            .dropWhile(isUsingClause)
-            .drop(1)
-            .dropWhile(isUsingClause)
-          (paramss.take(paramss.length - trailing.length), trailing)
-
     dclTextOr(tree) {
       val defKeyword = modText(tree.mods, tree.symbol, keywordStr("def"), isType = false)
       val isExtension = tree.hasType && tree.symbol.is(ExtensionMethod)
       withEnclosingDef(tree) {
         val (prefix, vparamss) =
           if isExtension then
-            val (leadingParamss, otherParamss) = splitParams(tree.vparamss)
+            val vparamss =
+              if tree.name.isRightAssocOperatorName then
+                // we have the encoding: leadingUsing rightParam trailingUsing leftParam
+                // we need to swap rightParam and leftParam
+                val (leadingUsing, rest1) = tree.vparamss.span(isUsingClause)
+                val (rightParamss, rest2) = rest1.splitAt(1)
+                val (trailingUsing, rest3) = rest2.span(isUsingClause)
+                val (leftParamss, rest4) = rest3.splitAt(1)
+                if leftParamss.nonEmpty then
+                  leadingUsing ::: leftParamss ::: trailingUsing ::: rightParamss ::: rest4
+                else
+                  tree.vparamss // it wasn't a binary operator, after all.
+              else
+                tree.vparamss
+            val trailingParamss = vparamss
+              .dropWhile(isUsingClause)
+              .drop(1)
+              .dropWhile(isUsingClause)
+            val leadingParamss = vparamss.take(vparamss.length - trailingParamss.length)
             (addVparamssText(keywordStr("extension "), leadingParamss)
              ~~ (defKeyword ~~ valDefText(nameIdText(tree))).close,
-             otherParamss)
+             trailingParamss)
           else (defKeyword ~~ valDefText(nameIdText(tree)), tree.vparamss)
 
         addVparamssText(prefix ~ tparamsText(tree.tparams), vparamss) ~

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

@@ -58,10 +58,7 @@ The three definitions above translate to
 Note the swap of the two parameters `x` and `xs` when translating
 the right-associative operator `+:` to an extension method. This is analogous
 to the implementation of right binding operators as normal methods. The Scala
-compiler preprocesses an infix operation `x +: xs` to `xs.+:(x)`, so the extension
-method ends up being applied to the sequence as first argument (in other words,
-the two swaps cancel each other out).
-
+compiler preprocesses an infix operation `x +: xs` to `xs.+:(x)`, so the extension method ends up being applied to the sequence as first argument (in other words, the two swaps cancel each other out).
 ### Generic Extensions
 
 It is also possible to extend generic types by adding type parameters to an extension. For instance:

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

@@ -0,0 +1,45 @@
+---
+layout: doc-page
+title: "Right-Associative Extension Methods: Details"
+---
+
+The most general form of leading parameters of an extension method is as follows:
+
+  - A possibly empty list of using clauses `leadingUsing`
+  - A single parameter `extensionParam`
+  - A possibly empty list of using clauses `trailingUsing`
+
+This is then followed by `def`, the method name, and possibly further parameters
+`otherParams`. An example is:
+
+```scala
+  extension (using a: A, b: B)(using c: C)    // <-- leadingUsing
+            (x: X)                            // <-- extensionParam
+            (using d: D)                      // <-- trailingUsing
+    def +:: (y: Y)(using e: E)(z: Z)          // <-- otherParams
+```
+An extension method is treated as a right associative operator if
+it has a name ending in `:` and is immediately followed by a
+single parameter. In the example above, that parameter is `(y: Y)`.
+
+The Scala compiler pre-processes a right-associative infix operation such as `x +: xs`
+to `xs.+:(x)` if `x` and `xs` are pure expressions and to `val y = x; xs +: y` otherwise. This is necessary since a regular right-associative infix method
+is defined in the class of its right operand. To make up for this swap,
+the expansion of right-associative extension methods performs an analogous parameter swap. More precisely, if `otherParams` consists of a single parameter
+`rightParam` followed by `remaining`, the total parameter sequence
+of the extension method's expansion is:
+```
+    leadingUsing  rightParam  trailingUsing  extensionParam  remaining
+```
+For instance, the `+::` method above would become
+```scala
+  <extension> def +:: (using a: A, b: B)(using c: C)
+                      (y: Y)
+                      (using d: D)
+                      (x: X)
+                      (using e: E)(z: Z)
+```
+This expansion has to be kept in mind when writing right-associative extension
+methods with inter-parameter dependencies.
+
+An overall simpler design could be obtained if right-associative operators could _only_ be defined as extension methods, and would be disallowed as normal methods. In that case neither arguments nor parameters would have to be swapped. Future versions of Scala should strive to achieve this simplification.

tests/run/i9530.check

@@ -0,0 +1,6 @@
+Expr(123)
+123
+Expr(123)
+123
+Expr(1234)
+1234

tests/pos/i9530.scala renamed to tests/run/i9530.scala

@@ -3,12 +3,12 @@ trait Scope:
    type Value
    def expr(x: String): Expr
    def value(e: Expr): Value
-   def combine(e: Expr, str: String): Expr
+   def combine(e1: Expr, e2: Expr): Expr
 
 extension (using s: Scope)(expr: s.Expr)
    def show = expr.toString
    def eval = s.value(expr)
-   def *: (str: String) = s.combine(expr, str)
+   def *: (other: s.Expr) = s.combine(expr, other)
 
 def f(using s: Scope)(x: s.Expr): (String, s.Value) =
    (x.show, x.eval)
@@ -18,7 +18,7 @@ given scope: Scope with
    type Value = Int
    def expr(x: String) = Expr(x)
    def value(e: Expr) = e.str.toInt
-   def combine(e: Expr, str: String) = Expr(e.str ++ str)
+   def combine(e1: Expr, e2: Expr) = Expr(e1.str ++ e2.str)
 
 @main def Test =
    val e = scope.Expr("123")
@@ -29,7 +29,7 @@ given scope: Scope with
    println(ss)
    val vv = e.eval
    println(vv)
-   val e2 = e *: "4"
+   val e2 = e *: scope.Expr("4")
    println(e2.show)
    println(e2.eval)