Uniformise naming of clauses in right associative extension methods

Author: Sporarum

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

@@ -915,16 +915,16 @@ object desugar {
       name = normalizeName(mdef, mdef.tpt).asTermName,
       paramss =
         if mdef.name.isRightAssocOperatorName then
-          val (typaramss, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
+          val (rightTyParams, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
 
           paramss match
-            case params :: paramss1 => // `params` must have a single parameter and without `given` flag
+            case rightParam :: paramss1 => // `rightParam` must have a single parameter and without `given` flag
 
               def badRightAssoc(problem: String) =
                 report.error(em"right-associative extension method $problem", mdef.srcPos)
                 extParamss ++ mdef.paramss
 
-              params match
+              rightParam match
                 case ValDefs(vparam :: Nil) =>
                   if !vparam.mods.is(Given) then
                     // we merge the extension parameters with the method parameters,
@@ -934,8 +934,10 @@ object desugar {
                     //     def %:[E](f: F)(g: G)(using H): Res = ???
                     // will be encoded as
                     //   def %:[A](using B)[E](f: F)(c: C)(using D)(g: G)(using H): Res = ???
-                    val (leadingUsing, otherExtParamss) = extParamss.span(isUsingOrTypeParamClause)
-                    leadingUsing ::: typaramss ::: params :: otherExtParamss ::: paramss1
+                    //
+                    // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
+                    val (leftTyParamsAndLeadingUsing, leftParamAndTrailingUsing) = extParamss.span(isUsingOrTypeParamClause)
+                    leftTyParamsAndLeadingUsing ::: rightTyParams ::: rightParam :: leftParamAndTrailingUsing ::: paramss1
                   else
                     badRightAssoc("cannot start with using clause")
                 case _ =>

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

@@ -895,30 +895,31 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           if isExtension then
             val paramss =
               if tree.name.isRightAssocOperatorName then
+                // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
                 // we have the following encoding of tree.paramss:
-                //   (leadingTyParamss ++ leadingUsing
-                //      ++ rightTyParamss ++ rightParamss
-                //      ++ leftParamss ++ trailingUsing ++ rest)
+                //   (leftTyParams ++ leadingUsing
+                //      ++ rightTyParams ++ rightParam
+                //      ++ leftParam ++ trailingUsing ++ rest)
                 //   e.g.
                 //     extension [A](using B)(c: C)(using D)
                 //       def %:[E](f: F)(g: G)(using H): Res = ???
                 //   will have the following values:
-                //   - leadingTyParamss = List(`[A]`)
+                //   - leftTyParams = List(`[A]`)
                 //   - leadingUsing = List(`(using B)`)
-                //   - rightTyParamss = List(`[E]`)
-                //   - rightParamss = List(`(f: F)`)
-                //   - leftParamss = List(`(c: C)`)
+                //   - rightTyParams = List(`[E]`)
+                //   - rightParam = List(`(f: F)`)
+                //   - leftParam = List(`(c: C)`)
                 //   - trailingUsing = List(`(using D)`)
                 //   - rest = List(`(g: G)`, `(using H)`)
-                // we need to swap (rightTyParams ++ rightParamss) with (leftParamss ++ trailingUsing)
-                val (leadingTyParamss, rest1) = tree.paramss.span(isTypeParamClause)
+                // we need to swap (rightTyParams ++ rightParam) with (leftParam ++ trailingUsing)
+                val (leftTyParams, rest1) = tree.paramss.span(isTypeParamClause)
                 val (leadingUsing, rest2) = rest1.span(isUsingClause)
-                val (rightTyParamss, rest3) = rest2.span(isTypeParamClause)
-                val (rightParamss, rest4) = rest3.splitAt(1)
-                val (leftParamss, rest5) = rest4.splitAt(1)
+                val (rightTyParams, rest3) = rest2.span(isTypeParamClause)
+                val (rightParam, rest4) = rest3.splitAt(1)
+                val (leftParam, rest5) = rest4.splitAt(1)
                 val (trailingUsing, rest6) = rest5.span(isUsingClause)
-                if leftParamss.nonEmpty then
-                  leadingTyParamss ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
+                if leftParam.nonEmpty then
+                  leftTyParams ::: leadingUsing ::: leftParam ::: trailingUsing ::: rightTyParams ::: rightParam ::: rest6
                 else
                   tree.paramss // it wasn't a binary operator, after all.
               else

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

@@ -4,44 +4,48 @@ title: "Right-Associative Extension Methods: Details"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/right-associative-extension-methods.html
 ---
 
+<!-- In case the names of the clauses are modified, also modify them in ClassLikeSupport, Desugar, and RefinedPrinter -->
+
 The most general signature an extension method can have is as follows:
-  - An optional type clause `leadingTyParamss`
+  - An optional type clause `leftTyParams`
   - A possibly empty list of using clauses `leadingUsing`
-  - A single parameter `leftParamss`
+  - A single parameter `leftParam` (in an explicit term clause)
   - A possibly empty list of using clauses `trailingUsing`
   - A name (preceded by the `def` keyword)
-  - An optional type clause `rightTyParamss`
-  - An optional explicit term clause `rightParamss`
+  - An optional type clause `rightTyParams`
+  - An optional single parameter `rightParam` (in an explicit term clause)
   - Any number of any clauses `rest`
 
 For example:
 
 ```scala
-  extension [T]                               // <-- leadingTyParamss
+  extension [T]                               // <-- leftTyParams
             (using a: A, b: B)(using c: C)    // <-- leadingUsing
-            (x: X)                            // <-- leftParamss
+            (x: X)                            // <-- leftParam
             (using d: D)                      // <-- trailingUsing
-    def +:: [U]                               // <-- rightTyParamss
-            (y: Y)                            // <-- rightParamss
+    def +:: [U]                               // <-- rightTyParams
+            (y: Y)                            // <-- rightParam
             [V](using e: E)[W](z: Z)          // <-- rest
 ```
 
 
 An extension method is treated as a right-associative operator
 (as in [SLS §6.12.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#infix-operations))
 if it has a name ending in `:`, and is immediately followed by a
-single explicit term parameter (in other words, `rightParamss` is present). In the example above, that parameter is `(y: Y)`.
+single explicit term parameter (in other words, `rightParam` is present). 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` is a pure expression or a call-by-name parameter 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 the inverse parameter swap. More precisely, if `rightParamss` is present, the total parameter sequence
+the expansion of right-associative extension methods performs the inverse parameter swap. More precisely, if `rightParam` is present, the total parameter sequence
 of the extension method's expansion is:
 
 ```
-    leadingTyParamss  leadingUsing  rightTyParamss  rightParamss  leftParamss  trailingUsing  rest
+    leftTyParams  leadingUsing  rightTyParams  rightParam  leftParam  trailingUsing  rest
 ```
 
+In other words, we swap `leftParams  trailingUsing` with `rightTyParam  rightParam`.
+
 For instance, the `+::` method above would become
 
 ```scala

scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala

@@ -349,16 +349,17 @@ trait ClassLikeSupport:
     val unshuffledMemberInfoParamLists = 
       if methodSymbol.isExtensionMethod && methodSymbol.isRightAssoc then
         // Taken from RefinedPrinter.scala
-        val (leadingTyParamss, rest1) = memberInfo.paramLists.span(_.isType)
+        // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
+        val (leftTyParams, rest1) = memberInfo.paramLists.span(_.isType)
         val (leadingUsing, rest2) = rest1.span(_.isUsing)
-        val (rightTyParamss, rest3) = rest2.span(_.isType)
-        val (rightParamss, rest4) = rest3.splitAt(1)
-        val (leftParamss, rest5) = rest4.splitAt(1)
+        val (rightTyParams, rest3) = rest2.span(_.isType)
+        val (rightParam, rest4) = rest3.splitAt(1)
+        val (leftParam, rest5) = rest4.splitAt(1)
         val (trailingUsing, rest6) = rest5.span(_.isUsing)
-        if leftParamss.nonEmpty then
-          // leadingTyParamss ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
+        if leftParam.nonEmpty then
+          // leftTyParams ::: leadingUsing ::: leftParam ::: trailingUsing ::: rightTyParams ::: rightParam ::: rest6
           // because of takeRight after, this is equivalent to the following:
-          rightTyParamss ::: rightParamss ::: rest6
+          rightTyParams ::: rightParam ::: rest6
         else
           memberInfo.paramLists // it wasn't a binary operator, after all.
       else