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))