address review: try length if lengthCompare unavailable

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_lengthR = SeqClass.requiredMethodRef(nme.length)
+    def Seq_length(implicit ctx: Context) = Seq_lengthR.symbol
     lazy val Seq_toSeqR = SeqClass.requiredMethodRef(nme.toSeq)
     def Seq_toSeq(implicit ctx: Context) = Seq_toSeqR.symbol
 

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

@@ -643,11 +643,18 @@ object PatternMatcher {
         case EqualTest(tree) =>
           tree.equal(scrutinee)
         case LengthTest(len, exact) =>
-          scrutinee
-            .select(defn.Seq_lengthCompare.matchingMember(scrutinee.tpe))
-            .appliedTo(Literal(Constant(len)))
-            .select(if (exact) defn.Int_== else defn.Int_>=)
-            .appliedTo(Literal(Constant(0)))
+          val lengthCompareSym = defn.Seq_lengthCompare.matchingMember(scrutinee.tpe)
+          if (lengthCompareSym.exists)
+            scrutinee
+              .select(defn.Seq_lengthCompare.matchingMember(scrutinee.tpe))
+              .appliedTo(Literal(Constant(len)))
+              .select(if (exact) defn.Int_== else defn.Int_>=)
+              .appliedTo(Literal(Constant(0)))
+          else // try length
+            scrutinee
+              .select(defn.Seq_length.matchingMember(scrutinee.tpe))
+              .select(if (exact) defn.Int_== else defn.Int_>=)
+              .appliedTo(Literal(Constant(len)))
         case TypeTest(tpt) =>
           val expectedTp = tpt.tpe
 

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

@@ -100,29 +100,34 @@ object Applications {
       Nil
     }
 
-    def validUnapplySeqType(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 = extractorMemberType(getTp, nme.toSeq).elemType.hiBound
-        getTp <:< superType(seqArg)
-      }
+    def unapplySeqTypeElemTp(getTp: Type): Type = {
+      val lengthTp = ExprType(defn.IntType)
+      val lengthCompareTp = MethodType(List("len".toTermName))(_ => defn.IntType :: Nil, _ => defn.IntType)
+      def applyTp(elemTp: Type) = MethodType(List("i".toTermName))(_ => defn.IntType :: Nil, _ => elemTp)
+      def dropTp(elemTp: Type) = MethodType(List("n".toTermName))(_ => defn.IntType :: Nil, _ => defn.SeqType.appliedTo(elemTp))
+      def toSeqTp(elemTp: Type) = ExprType(defn.SeqType.appliedTo(elemTp))
+
+      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))
+
+      val valid = getTp <:< RefinedType.make(defn.AnyType, names1, types1) ||
+                  getTp <:< RefinedType.make(defn.AnyType, names2, types2)
+
+      if (valid) elemTp else NoType
     }
 
+    def validUnapplySeqType(getTp: Type): Boolean = unapplySeqTypeElemTp(getTp).exists
+
     if (unapplyName == nme.unapplySeq) {
       if (unapplyResult derivesFrom defn.SeqClass) seqSelector :: Nil
       else if (isGetMatch(unapplyResult, pos) && validUnapplySeqType(getTp)) {
-        val seqArg = extractorMemberType(getTp, nme.toSeq).elemType.hiBound
-        if (seqArg.exists) args.map(Function.const(seqArg))
-        else fail
+        val elemTp = unapplySeqTypeElemTp(getTp)
+        args.map(Function.const(elemTp))
       }
       else fail
     }

tests/run/i4984c.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 length: Int = 2
+    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))
+  }
+}