address review

Author: liufengyun

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

@@ -254,7 +254,7 @@ object PatternMatcher {
        */
       def matchElemsPlan(seqSym: Symbol, args: List[Tree], exact: Boolean, onSuccess: Plan) = {
         val selectors = args.indices.toList.map(idx =>
-          ref(seqSym).select(nme.apply).appliedTo(Literal(Constant(idx))))
+          ref(seqSym).select(defn.Seq_apply.matchingMember(seqSym.info)).appliedTo(Literal(Constant(idx))))
         TestPlan(LengthTest(args.length, exact), seqSym, seqSym.pos,
           matchArgsPlan(selectors, args, onSuccess))
       }

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

@@ -109,25 +109,21 @@ object Applications {
 
       val elemTp = getTp.member(nme.apply).suchThat(_.info <:< applyTp(WildcardType)).info.resultType
 
-      def names1 = List(nme.lengthCompare, nme.apply, nme.drop, nme.toSeq)
-      def types1 = List(lengthCompareTp, applyTp(elemTp), dropTp(elemTp), toSeqTp(elemTp))
-
-      def names2 = List(nme.length, nme.apply, nme.drop, nme.toSeq)
-      def types2 = List(lengthTp, applyTp(elemTp), dropTp(elemTp), toSeqTp(elemTp))
+      def test(name: Name, tp: Type) = getTp.member(name).suchThat(_.info <:< tp).exists
 
       val valid = elemTp.exists &&
-                  (getTp <:< RefinedType.make(defn.AnyType, names1, types1) ||
-                  getTp <:< RefinedType.make(defn.AnyType, names2, types2))
+        (test(nme.lengthCompare, lengthCompareTp) || test(nme.length, lengthTp)) &&
+        test(nme.drop, dropTp(elemTp)) &&
+        test(nme.toSeq, toSeqTp(elemTp))
 
       if (valid) elemTp else NoType
     }
 
-    def validUnapplySeqType(getTp: Type): Boolean = unapplySeqTypeElemTp(getTp).exists
-
     if (unapplyName == nme.unapplySeq) {
-      if (isGetMatch(unapplyResult, pos) && validUnapplySeqType(getTp)) {
+      if (isGetMatch(unapplyResult, pos)) {
         val elemTp = unapplySeqTypeElemTp(getTp)
-        args.map(Function.const(elemTp))
+        if (elemTp.exists) args.map(Function.const(elemTp))
+        else fail
       }
       else fail
     }

tests/run/i4984e.scala

@@ -0,0 +1,36 @@
+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 lengthCompare: Int = 0
+    def apply(i: Int): Int = 3
+    def apply(i: String): Int = 3
+    def drop(n: Int): scala.Seq[Int] = Seq(2, 5)
+    def drop: scala.Seq[Int] = Seq(2, 5)
+    def toSeq: scala.Seq[Int] = Seq(6, 7)
+    def toSeq(x: Int): 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))
+  }
+}