Fix #4984: support name-based unapplySeq

Author: liufengyun

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -422,6 +422,8 @@ class Definitions {
     def Seq_drop(implicit ctx: Context) = Seq_dropR.symbol
     lazy val Seq_lengthCompareR = SeqClass.requiredMethodRef(nme.lengthCompare)
     def Seq_lengthCompare(implicit ctx: Context) = Seq_lengthCompareR.symbol
+    lazy val Seq_toSeqR = SeqClass.requiredMethodRef(nme.toSeq)
+    def Seq_toSeq(implicit ctx: Context) = Seq_toSeqR.symbol
 
   lazy val ArrayType: TypeRef = ctx.requiredClassRef("scala.Array")
   def ArrayClass(implicit ctx: Context) = ArrayType.symbol.asClass

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -265,8 +265,13 @@ object PatternMatcher {
       def unapplySeqPlan(getResult: Symbol, args: List[Tree]): Plan = args.lastOption match {
         case Some(VarArgPattern(arg)) =>
           val matchRemaining =
-            if (args.length == 1)
-              patternPlan(getResult, arg, onSuccess)
+            if (args.length == 1) {
+              val toSeq = ref(getResult)
+                .select(defn.Seq_toSeq.matchingMember(getResult.info))
+              letAbstract(toSeq) { toSeqResult =>
+                patternPlan(toSeqResult, arg, onSuccess)
+              }
+            }
             else {
               val dropped = ref(getResult)
                 .select(defn.Seq_drop.matchingMember(getResult.info))

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

@@ -100,10 +100,27 @@ object Applications {
       Nil
     }
 
+    def vaidUnapplySeqType(getTp: Type): Boolean = {
+      def superType(elemTp: Type) = {
+        val tps = List(
+          MethodType(List("len".toTermName))(_ => defn.IntType :: Nil, _ => defn.IntType),
+          MethodType(List("i".toTermName))(_ => defn.IntType :: Nil, _ => elemTp),
+          MethodType(List("n".toTermName))(_ => defn.IntType :: Nil, _ => defn.SeqType.appliedTo(elemTp)),
+          ExprType(defn.SeqType.appliedTo(elemTp)),
+        )
+        val names = List(nme.lengthCompare, nme.apply, nme.drop, nme.toSeq)
+        RefinedType.make(defn.AnyType, names, tps)
+      }
+      getTp <:< superType(WildcardType)  && {
+        val seqArg = getTp.member(nme.toSeq).info.elemType.hiBound
+        getTp <:< superType(seqArg)
+      }
+    }
+
     if (unapplyName == nme.unapplySeq) {
       if (unapplyResult derivesFrom defn.SeqClass) seqSelector :: Nil
-      else if (isGetMatch(unapplyResult, pos) && getTp.derivesFrom(defn.SeqClass)) {
-        val seqArg = getTp.elemType.hiBound
+      else if (isGetMatch(unapplyResult, pos) && vaidUnapplySeqType(getTp)) {
+        val seqArg = getTp.member(nme.apply).info.finalResultType
         if (seqArg.exists) args.map(Function.const(seqArg))
         else fail
       }

tests/pos/i4984.scala

@@ -0,0 +1,26 @@
+object Array2 {
+  def unapplySeq[T](x: Array[T]): UnapplySeqWrapper[T] = new UnapplySeqWrapper(x)
+
+  final class UnapplySeqWrapper[T](private val a: Array[T]) extends AnyVal {
+    def isEmpty: Boolean = false
+    def get: UnapplySeqWrapper[T] = this
+    def lengthCompare(len: Int): Int = a.lengthCompare(len)
+    def apply(i: Int): T = a(i)
+    def drop(n: Int): scala.Seq[T] = ???
+    def toSeq: scala.Seq[T] = a.toSeq // clones the array
+  }
+}
+
+class Test {
+  def test1(xs: Array[Int]): Int = xs match {
+    case Array2(x, y) => x + y
+  }
+
+  def test2(xs: Array[Int]): Seq[Int] = xs match {
+    case Array2(x, y, xs:_*) => xs
+  }
+
+  def test3(xs: Array[Int]): Seq[Int] = xs match {
+    case Array2(xs:_*) => xs
+  }
+}

tests/run/i4984b.scala

@@ -0,0 +1,32 @@
+object Array2 {
+  def unapplySeq(x: Array[Int]): Data = new Data
+
+  final class Data {
+    def isEmpty: Boolean = false
+    def get: Data = this
+    def lengthCompare(len: Int): Int = 0
+    def apply(i: Int): Int = 3
+    def drop(n: Int): scala.Seq[Int] = Seq(2, 5)
+    def toSeq: scala.Seq[Int] = Seq(6, 7)
+  }
+}
+
+object Test {
+  def test1(xs: Array[Int]): Int = xs match {
+    case Array2(x, y) => x + y
+  }
+
+  def test2(xs: Array[Int]): Seq[Int] = xs match {
+    case Array2(x, y, xs:_*) => xs
+  }
+
+  def test3(xs: Array[Int]): Seq[Int] = xs match {
+    case Array2(xs:_*) => xs
+  }
+
+  def main(args: Array[String]): Unit = {
+    test1(Array(3, 5))
+    test2(Array(3, 5))
+    test3(Array(3, 5))
+  }
+}