refactor and add comments

Author: bishabosha

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

@@ -902,28 +902,37 @@ object desugar {
       defDef(
         cpy.DefDef(mdef)(
           name = normalizeName(mdef, ext).asTermName,
-          paramss = mdef.paramss match
-            case params1 :: paramss1 if mdef.name.isRightAssocOperatorName =>
-              def badRightAssoc(problem: String) =
-                report.error(i"right-associative extension method $problem", mdef.srcPos)
-                ext.paramss ++ mdef.paramss
-              def noVParam = badRightAssoc("must start with a single parameter")
-              def checkVparam(pre: List[ParamClause], params: ParamClause, paramss: List[ParamClause]) = params match
-                case ValDefs(vparam :: Nil) =>
-                  if !vparam.mods.is(Given) then
-                    val (leadingUsing, otherExtParamss) = ext.paramss.span(isUsingOrTypeParamClause)
-                    leadingUsing ::: pre ::: params :: otherExtParamss ::: paramss
-                  else badRightAssoc("cannot start with using clause")
+          paramss =
+            if mdef.name.isRightAssocOperatorName then
+              val (typaramss, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
+
+              paramss match
+                case params :: paramss1 => // `params` must have a single parameter and without `given` flag
+
+                  def badRightAssoc(problem: String) =
+                    report.error(i"right-associative extension method $problem", mdef.srcPos)
+                    ext.paramss ++ mdef.paramss
+
+                  params match
+                    case ValDefs(vparam :: Nil) =>
+                      if !vparam.mods.is(Given) then
+                        // we merge the extension parameters with the method parameters,
+                        // swapping the operator arguments:
+                        // e.g.
+                        //   extension [A](using B)(c: C)(using D)
+                        //     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) = ext.paramss.span(isUsingOrTypeParamClause)
+                        leadingUsing ::: typaramss ::: params :: otherExtParamss ::: paramss1
+                      else
+                        badRightAssoc("cannot start with using clause")
+                    case _ =>
+                      badRightAssoc("must start with a single parameter")
                 case _ =>
-                  noVParam
-              params1 match
-                case TypeDefs(_) => paramss1 match
-                  case params2 :: paramss2 => checkVparam(params1::Nil, params2, paramss2)
-                  case _                   => noVParam
-                case _ =>
-                  checkVparam(Nil, params1, paramss1)
-
-            case _ =>
+                  // no value parameters, so not an infix operator.
+                  ext.paramss ++ mdef.paramss
+            else
               ext.paramss ++ mdef.paramss
         ).withMods(mdef.mods | ExtensionMethod)
       )

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

@@ -815,16 +815,30 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           if isExtension then
             val paramss =
               if tree.name.isRightAssocOperatorName then
-                // we have the encoding: leadingTy leadingUsing rightTyParamss rightParamss leftParamss trailingUsing
+                // we have the following encoding of tree.paramss:
+                //   (leadingTyParamss ++ leadingUsing
+                //      ++ rightTyParamss ++ rightParamss
+                //      ++ leftParamss ++ 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]`)
+                //   - leadingUsing = List(`(using B)`)
+                //   - rightTyParamss = List(`[E]`)
+                //   - rightParamss = List(`(f: F)`)
+                //   - leftParamss = List(`(c: C)`)
+                //   - trailingUsing = List(`(using D)`)
+                //   - rest = List(`(g: G)`, `(using H)`)
                 // we need to swap (rightTyParams ++ rightParamss) with (leftParamss ++ trailingUsing)
-                val (leadingTy, rest1) = tree.paramss.span(isTypeParamClause)
+                val (leadingTyParamss, 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 (trailingUsing, rest6) = rest5.span(isUsingClause)
                 if leftParamss.nonEmpty then
-                  leadingTy ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
+                  leadingTyParamss ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
                 else
                   tree.paramss // it wasn't a binary operator, after all.
               else

tests/run/i11583.scala

@@ -15,9 +15,8 @@ class Env:
 extension [Ctx <: Context](using ctx: Ctx)(tpe: String)(using env: Env)
   def :#:[T <: Boolean](trm: T)(ext: env.Extra): (String, T, env.Extra) = (tpe, trm, ext)
 
-
-extension (s: String)
-  def :*:[T <: Tuple](t: T): String *: T = s *: t
+extension [A](a: A)
+  def :*:[T <: Tuple](t: T): A *: T = a *: t
 
 @main def Test =