Fix #6253: Handle repeated args in quoted patterns

[nicolasstucki]

• Handle repeated args in quoted patterns in Typer
• Handle repeated args in quoted patterns in Matcher
• Add Repeated extractor to get Seq[Expr[T]] from an Expr[Seq[T]]

[liufengyun]

Otherwise, LGTM

[liufengyun]

The change here and above looks dubious to me. @odersky could you have a look?

[odersky]

I am not sure a global substitution is the right thing here. I fear it would also affect nested varargs methods that would then become Seq methods. I'd do instead:

val patType = pat.tpe.widen
val patType1 = patType.underlyingIfRepeated(isJava = false)
val pat1 = if (patType eq patType1) pat else pat.withType(patType1)

[nicolasstucki]

I use this code now and also updated another place that had the subst to use underlyingIfRepeated.

[odersky]

I am not sure a global substitution is the right thing here. I fear it would also affect nested varargs methods that would then become Seq methods. I'd do instead:

val patType = pat.tpe.widen
val patType1 = patType.underlyingIfRepeated(isJava = false)
val pat1 = if (patType eq patType1) pat else pat.withType(patType1)

[liufengyun]

I reverted the changes in Typer, and the tests in this PR pass:

--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -581,7 +581,7 @@ class Typer extends Namer
     if (untpd.isWildcardStarArg(tree)) {
       def typedWildcardStarArgExpr = {
         val ptArg =
-          if (ctx.mode.is(Mode.QuotedPattern)) pt.underlyingIfRepeated(isJava = false)
+          if (ctx.mode.is(Mode.QuotedPattern)) pt
           else WildcardType
         val tpdExpr = typedExpr(tree.expr, ptArg)
         tpdExpr.tpe.widenDealias match {
@@ -1963,17 +1963,12 @@ class Typer extends Namer
     object splitter extends tpd.TreeMap {
       val patBuf = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(implicit ctx: Context) = tree match {
-        case Typed(Splice(pat), tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
+        case Typed(Splice(pat), tpt) =>
           val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprType), tpt :: Nil)
           transform(Splice(Typed(pat, exprTpt)))
         case Splice(pat) =>
           try patternHole(tree)
-          finally {
-            val patType = pat.tpe.widen
-            val patType1 = patType.underlyingIfRepeated(isJava = false)
-            val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
-            patBuf += pat1
-          }
+          finally patBuf += pat
         case _ =>
           super.transform(tree)
       }

I still fail to understand the rational to go to an underlying type. Could you please elaborate @nicolasstucki ?

[nicolasstucki]

We want to avoid having expressions of type T* as we could not write val a: T* = ???. Instead we use val a: Seq[T] = ???.