Merge pull request #11691 from dotty-staging/fix-right-assoc-extension

fix param desugar in right-associative extensions

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(params: ParamClause) = params match
-                case ValDefs(vparam :: Nil) =>
-                  if !vparam.mods.is(Given) then
-                    val (leadingUsing, otherExtParamss) = ext.paramss.span(isUsingOrTypeParamClause)
-                    leadingUsing ::: params1 :: otherExtParamss ::: paramss1
-                  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 :: _ => checkVparam(params2)
-                  case _            => noVParam
-                case _ =>
-                  checkVparam(params1)
-
-            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/ast/TreeInfo.scala

@@ -251,6 +251,10 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case TypeDefs(_) => true
     case _ => isUsingClause(params)
 
+  def isTypeParamClause(params: ParamClause)(using Context): Boolean = params match
+    case TypeDefs(_) => true
+    case _ => false
+
   private val languageSubCategories = Set(nme.experimental, nme.deprecated)
 
   /** If `path` looks like a language import, `Some(name)` where name

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

@@ -815,14 +815,30 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           if isExtension then
             val paramss =
               if tree.name.isRightAssocOperatorName then
-                // we have the encoding: leadingUsingOrTypeParams rightParam trailingUsing leftParam
-                // we need to swap rightParam and leftParam
-                val (leadingUsing, rest1) = tree.paramss.span(isUsingOrTypeParamClause)
-                val (rightParamss, rest2) = rest1.splitAt(1)
-                val (trailingUsing, rest3) = rest2.span(isUsingClause)
-                val (leftParamss, rest4) = rest3.splitAt(1)
+                // 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 (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
-                  leadingUsing ::: leftParamss ::: trailingUsing ::: rightParamss ::: rest4
+                  leadingTyParamss ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
                 else
                   tree.paramss // it wasn't a binary operator, after all.
               else

tests/pos/i11583.scala

@@ -0,0 +1,38 @@
+class Context:
+  type Type
+  type Term
+
+class Env:
+  type Extra
+
+// TODO: enable after https://github.com/lampepfl/dotty/issues/11700 is fixed
+// extension [Ctx <: Context](using ctx: Ctx)(tpe: ctx.Type)(using env: Env)
+//   /** essentially: `extension (s: String) def &&:(b: Boolean)(i: Int)`
+//     * but exercises the RefinedPrinter and safety of reordering parameters
+//     */
+//   def &&:[T <: ctx.Term](trm: T)(ext: env.Extra): (ctx.Type, T, env.Extra) = (tpe, trm, ext)
+
+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 [A](a: A)
+  def :*:[T <: Tuple](t: T): A *: T = a *: t
+
+@main def Test =
+
+  given Context with
+    type Type = String
+    type Term = Boolean
+
+  given Env with
+    type Extra = Int
+
+  val t1: (String, Boolean, Int) = true.:#:("hello")(23)
+  // val t2: (String, Boolean, Int) = true.&&:("hello")(23)
+  val t3: (String, Boolean, Int) = "hello" :*: (true, 23)
+  val t4: (String, Boolean, Int) = (true, 23).:*:("hello")
+
+  assert(t1 == ("hello", true, 23))
+  // assert(t2 == ("hello", true, 23))
+  assert(t3 == ("hello", true, 23))
+  assert(t4 == ("hello", true, 23))