Revert #3248: generate unapplySeq for case class with varargs

Author: liufengyun

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

@@ -432,6 +432,12 @@ object desugar {
       appliedTypeTree(tycon, targs)
     }
 
+    def isRepeated(tree: Tree): Boolean = tree match {
+      case PostfixOp(_, Ident(tpnme.raw.STAR)) => true
+      case ByNameTypeTree(tree1) => isRepeated(tree1)
+      case _ => false
+    }
+
     // a reference to the class type bound by `cdef`, with type parameters coming from the constructor
     val classTypeRef = appliedRef(classTycon)
 
@@ -482,11 +488,6 @@ object desugar {
       }
       def enumTagMeths = if (isEnumCase) enumTagMeth(CaseKind.Class)._1 :: Nil else Nil
       def copyMeths = {
-        def isRepeated(tree: Tree): Boolean = tree match {
-          case PostfixOp(_, Ident(tpnme.raw.STAR)) => true
-          case ByNameTypeTree(tree1) => isRepeated(tree1)
-          case _ => false
-        }
         val hasRepeatedParam = constrVparamss.exists(_.exists {
           case ValDef(_, tpt, _) => isRepeated(tpt)
         })
@@ -560,7 +561,8 @@ object desugar {
     // companion definitions include:
     // 1. If class is a case class case class C[Ts](p1: T1, ..., pN: TN)(moreParams):
     //     def apply[Ts](p1: T1, ..., pN: TN)(moreParams) = new C[Ts](p1, ..., pN)(moreParams)  (unless C is abstract)
-    //     def unapply[Ts]($1: C[Ts]) = $1
+    //     def unapply[Ts]($1: C[Ts]) = $1        // if not repeated
+    //     def unapplySeq[Ts]($1: C[Ts]) = $1     // if repeated
     // 2. The default getters of the constructor
     // The parent of the companion object of a non-parameterized case class
     //     (T11, ..., T1N) => ... => (TM1, ..., TMN) => C
@@ -609,9 +611,13 @@ object desugar {
             app :: widenDefs
           }
         val unapplyMeth = {
+          val hasRepeatedParam = constrVparamss.head.exists {
+            case ValDef(_, tpt, _) => isRepeated(tpt)
+          }
+          val methName = if (hasRepeatedParam) nme.unapplySeq else nme.unapply
           val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
           val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name)
-          DefDef(nme.unapply, derivedTparams, (unapplyParam :: Nil) :: Nil, TypeTree(), unapplyRHS)
+          DefDef(methName, derivedTparams, (unapplyParam :: Nil) :: Nil, TypeTree(), unapplyRHS)
             .withMods(synthetic)
         }
         companionDefs(companionParent, applyMeths ::: unapplyMeth :: companionMembers)

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -133,7 +133,6 @@ object Applications {
     if (args.length > 1 && !(tp.derivesFrom(defn.SeqClass))) {
       val sels = productSelectorTypes(tp, pos)
       if (sels.length == args.length) sels
-      else if (isProductSeqMatch(tp, args.length, pos)) productSeqSelectors(tp, args.length, pos)
       else tp :: Nil
     } else tp :: Nil
 
@@ -147,7 +146,6 @@ object Applications {
   def unapplyArgs(unapplyResult: Type, unapplyFn: Tree, args: List[untpd.Tree], pos: SourcePosition)(implicit ctx: Context): List[Type] = {
 
     val unapplyName = unapplyFn.symbol.name
-    def seqSelector = defn.RepeatedParamType.appliedTo(unapplyResult.elemType :: Nil)
     def getTp = extractorMemberType(unapplyResult, nme.get, pos)
 
     def fail = {
@@ -1100,19 +1098,12 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
         var argTypes = unapplyArgs(unapplyApp.tpe, unapplyFn, args, tree.sourcePos)
         for (argType <- argTypes) assert(!isBounds(argType), unapplyApp.tpe.show)
-        val bunchedArgs =
-          if (argTypes.nonEmpty && argTypes.last.isRepeatedParam)
-            args.lastOption match {
-              case Some(arg @ Typed(argSeq, _)) if untpd.isWildcardStarArg(arg) =>
-                args.init :+ argSeq
-              case _ =>
-                val (regularArgs, varArgs) = args.splitAt(argTypes.length - 1)
-                regularArgs :+ untpd.SeqLiteral(varArgs, untpd.TypeTree()).withSpan(tree.span)
-            }
-          else if (argTypes.lengthCompare(1) == 0 && args.lengthCompare(1) > 0 && ctx.canAutoTuple)
-            untpd.Tuple(args) :: Nil
-          else
-            args
+        val bunchedArgs = argTypes match {
+          case argType :: Nil =>
+            if (args.lengthCompare(1) > 0 && ctx.canAutoTuple) untpd.Tuple(args) :: Nil
+            else args
+          case _ => args
+        }
         if (argTypes.length != bunchedArgs.length) {
           ctx.error(UnapplyInvalidNumberOfArguments(qual, argTypes), tree.sourcePos)
           argTypes = argTypes.take(args.length) ++

tests/run/i3248b.scala

@@ -1,7 +1,7 @@
 object Test {
   class Foo(val name: String, val children: Int *)
   object Foo {
-    def unapply(f: Foo) = Some((f.name, f.children))
+    def unapplySeq(f: Foo) = Some((f.name, f.children))
   }
 
   def foo(f: Foo) = f match {

tests/run/i3248d.scala

@@ -1,8 +1,12 @@
 object Test {
-  case class Foo(name: String, children: Seq[Int])
+  class Foo(val name: String, val children: Seq[Int])
+
+  object Foo {
+    def unapplySeq(foo: Foo): (String, Seq[Int]) = (foo.name, foo.children)
+  }
 
   def foo(f: Foo) = f match {
-    case Foo(name, ns) =>
+    case Foo(name, ns: _*) =>
       assert(name == "hello")
       assert(ns(0) == 3)
       assert(ns(1) == 5)
@@ -19,17 +23,17 @@ object Test {
   def qux(f: Foo) = f match {
     case Foo(name) => 1
     case Foo(name, x, y) => 2
-    case Foo(name, xs) => 0
+    case Foo(name, xs: _*) => 0
   }
 
 
   def main(args: Array[String]): Unit = {
-    val f = Foo("hello", List(3, 5))
+    val f = new Foo("hello", List(3, 5))
     foo(f)
     bar(f)
-    assert(qux(Foo("hello", Nil)) == 1)
-    assert(qux(Foo("hello", 5 :: 6 :: Nil)) == 2)
-    assert(qux(Foo("hello", 5 :: Nil)) == 0)
-    assert(qux(Foo("hello", 5 :: 6 :: 7 :: Nil)) == 0)
+    assert(qux(new Foo("hello", Nil)) == 1)
+    assert(qux(new Foo("hello", 5 :: 6 :: Nil)) == 2)
+    assert(qux(new Foo("hello", 5 :: Nil)) == 0)
+    assert(qux(new Foo("hello", 5 :: 6 :: 7 :: Nil)) == 0)
   }
 }