Make TypeTest.unapply conditionally irrefutable

Co-authored-by: Nicolas Stucki <[email protected]>

Author: liufengyun

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

@@ -768,6 +768,7 @@ class Definitions {
     @tu lazy val ClassTagModule_apply: Symbol = ClassTagModule.requiredMethod(nme.apply)
 
   @tu lazy val TypeTestClass: ClassSymbol = requiredClass("scala.reflect.TypeTest")
+    @tu lazy val TypeTest_unapply: Symbol = TypeTestClass.requiredMethod(nme.unapply)
   @tu lazy val TypeTestModule_identity: Symbol = TypeTestClass.companionModule.requiredMethod(nme.identity)
 
   @tu lazy val QuotedExprClass: ClassSymbol = requiredClass("scala.quoted.Expr")
@@ -922,7 +923,6 @@ class Definitions {
   @tu lazy val FunctionalInterfaceAnnot: ClassSymbol = requiredClass("java.lang.FunctionalInterface")
   @tu lazy val TargetNameAnnot: ClassSymbol = requiredClass("scala.annotation.targetName")
   @tu lazy val VarargsAnnot: ClassSymbol = requiredClass("scala.annotation.varargs")
-  @tu lazy val CoversAnnot: ClassSymbol = requiredClass("scala.annotation.covers")
 
   @tu lazy val JavaRepeatableAnnot: ClassSymbol = requiredClass("java.lang.annotation.Repeatable")
 

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -554,7 +554,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
     // Case unapplySeq:
     // 1. return the type `List[T]` where `T` is the element type of the unapplySeq return type `Seq[T]`
 
-    val resTp = mt.finalResultType
+    val resTp = mt.instantiate(scrutineeTp :: Nil).finalResultType
 
     val sig =
       if (resTp.isRef(defn.BooleanClass))
@@ -589,27 +589,9 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
   /** Whether the extractor covers the given type */
   def covers(unapp: TermRef, scrutineeTp: Type): Boolean =
-    SpaceEngine.isIrrefutable(unapp) || {
-      val mt: MethodType = unapp.widen match {
-        case mt: MethodType => mt
-        case pt: PolyType   =>
-          inContext(ctx.fresh.setExploreTyperState()) {
-            val tvars = pt.paramInfos.map(newTypeVar)
-            val mt = pt.instantiate(tvars).asInstanceOf[MethodType]
-            scrutineeTp <:< mt.paramInfos(0)
-            // force type inference to infer a narrower type: could be singleton
-            // see tests/patmat/i4227.scala
-            mt.paramInfos(0) <:< scrutineeTp
-            isFullyDefined(mt, ForceDegree.all)
-            mt
-          }
-      }
-
-      mt.finalResultType.dealiasKeepAnnots match
-        case AnnotatedType(tp, annot) if annot.matches(defn.CoversAnnot) =>
-          val Apply(TypeApply(_, tpt :: Nil), Nil) = annot.tree: @unchecked
-          scrutineeTp <:< tpt.tpe
-        case _ => false
+    SpaceEngine.isIrrefutable(unapp) || unapp.symbol == defn.TypeTest_unapply && {
+      val AppliedType(_, _ :: tp :: Nil) = unapp.prefix.widen
+      scrutineeTp <:< tp
     }
 
   /** Decompose a type into subspaces -- assume the type can be decomposed */

library/src/scala/annotation/covers.scala

@@ -1,7 +1,7 @@
 package scala.reflect
 
 /** A `TypeTest[S, T] contains the logic needed to know at runtime if a value of
- *  type `S` can be downcasted to `T`.
+ *  type `S` is an instance of `T`.
  *
  *  If a pattern match is performed on a term of type `s: S` that is uncheckable with `s.isInstanceOf[T]` and
  *  the pattern are of the form:
@@ -12,7 +12,7 @@ package scala.reflect
 @scala.annotation.implicitNotFound(msg = "No TypeTest available for [${S}, ${T}]")
 trait TypeTest[-S, T] extends Serializable:
 
-  /** A TypeTest[S, T] can serve as an extractor that matches only S of type T.
+  /** A TypeTest[S, T] can serve as an extractor that matches if and only if S of type T.
    *
    * The compiler tries to turn unchecked type tests in pattern matches into checked ones
    * by wrapping a `(_: T)` type pattern as `tt(_: T)`, where `tt` is the `TypeTest[S, T]` instance.

library/src/scala/reflect/TypeTest.scala

@@ -0,0 +1,22 @@
+import scala.quoted.*
+
+def qwe(using Quotes) = {
+  import quotes.reflect.*
+
+  def ko_1(param: ValDef | TypeDef) =
+    param match {
+      case _: ValDef =>
+      case _: TypeDef =>
+    }
+
+  def ko_2(params: List[ValDef] | List[TypeDef]) =
+    params.map {
+      case x: ValDef =>
+      case y: TypeDef =>
+    }
+
+  def ko_3(param: ValDef | TypeDef) =
+    param match {
+      case _: ValDef =>
+    }
+}

tests/patmat/i12020.scala

@@ -0,0 +1,5 @@
+def test[A, B](a: A|B)(using reflect.TypeTest[Any, A], reflect.TypeTest[Any, B]) =
+  a match {
+    case a: A =>
+    case b: B =>
+  }

tests/patmat/i12026.scala

@@ -0,0 +1,5 @@
+def test[A, B](a: A|B)(tta: reflect.TypeTest[Any, A], ttb: reflect.TypeTest[Any, B]) =
+  a match {
+    case tta(a: A) =>
+    case ttb(b: B) =>
+  }