fix param desugar in right-associative extensions

Author: bishabosha

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

@@ -908,20 +908,20 @@ object desugar {
                 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
+              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 ::: params1 :: otherExtParamss ::: paramss1
+                    leadingUsing ::: pre ::: params :: otherExtParamss ::: paramss
                   else badRightAssoc("cannot start with using clause")
                 case _ =>
                   noVParam
               params1 match
                 case TypeDefs(_) => paramss1 match
-                  case params2 :: _ => checkVparam(params2)
-                  case _            => noVParam
+                  case params2 :: paramss2 => checkVparam(params1::Nil, params2, paramss2)
+                  case _                   => noVParam
                 case _ =>
-                  checkVparam(params1)
+                  checkVparam(Nil, params1, paramss1)
 
             case _ =>
               ext.paramss ++ mdef.paramss

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,16 @@ 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 encoding: leadingTy leadingUsing rightTyParamss rightParamss leftParamss trailingUsing
+                // we need to swap (rightTyParams ++ rightParamss) with (leftParamss ++ trailingUsing)
+                val (leadingTy, 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
+                  leadingTy ::: 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,39 @@
+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 (s: String)
+  def :*:[T <: Tuple](t: T): String *: T = s *: 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))