Synthesize TypeTests

Author: nicolasstucki

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

@@ -632,6 +632,8 @@ class Definitions {
     @tu lazy val ClassTagModule_apply: Symbol = ClassTagModule.requiredMethod(nme.apply)
 
   @tu lazy val TypeTestClass: ClassSymbol = ctx.requiredClass("scala.reflect.TypeTest")
+  @tu lazy val TypeTestModule: Symbol = TypeTestClass.companionModule
+    @tu lazy val TypeTestModule_identity: Symbol = TypeTestModule.requiredMethod(nme.identity)
 
   @tu lazy val QuotedExprClass: ClassSymbol = ctx.requiredClass("scala.quoted.Expr")
   @tu lazy val QuotedExprModule: Symbol = QuotedExprClass.companionModule

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

@@ -705,6 +705,36 @@ trait Implicits { self: Typer =>
         EmptyTree
     }
 
+  lazy val synthesizedTypeTest: SpecialHandler =
+    (formal, span) => implicit ctx => formal.argInfos match {
+      case arg1 :: arg2 :: Nil if !defn.isBottomClass(arg2.typeSymbol) =>
+        val tp1 = fullyDefinedType(arg1, "TypeTest argument", span)
+        val tp2 = fullyDefinedType(arg2, "TypeTest argument", span)
+        val sym2 = tp2.typeSymbol
+        if tp1 <:< tp2 then
+          ref(defn.TypeTestModule_identity).appliedToType(tp2).withSpan(span)
+        else if sym2 == defn.AnyValClass || sym2 == defn.AnyRefAlias || sym2 == defn.ObjectClass then
+          EmptyTree
+        else
+          // Generate SAM: (s: <tp1>) => if s.isInstanceOf[s.type & <tp2>] then Some(s.asInstanceOf[s.type & <tp2>]) else None
+          def body(args: List[Tree]): Tree = {
+            val arg :: Nil = args
+            val t = arg.tpe & tp2
+            If(
+              arg.select(defn.Any_isInstanceOf).appliedToType(t),
+              ref(defn.SomeClass.companionModule.termRef).select(nme.apply)
+                .appliedToType(t)
+                .appliedTo(arg.select(nme.asInstanceOf_).appliedToType(t)),
+              ref(defn.NoneModule))
+          }
+          val tpe = MethodType(List(nme.s))(_ => List(tp1), mth => defn.OptionClass.typeRef.appliedTo(mth.newParamRef(0) & tp2))
+          val meth = ctx.newSymbol(ctx.owner, nme.ANON_FUN, Synthetic | Method, tpe, coord = span)
+          val typeTestType = defn.TypeTestClass.typeRef.appliedTo(List(tp1, tp2))
+          Closure(meth, tss => body(tss.head).changeOwner(ctx.owner, meth), targetType = typeTestType).withSpan(span)
+      case _ =>
+        EmptyTree
+    }
+
   /** Synthesize the tree for `'[T]` for an implicit `scala.quoted.Type[T]`.
    *  `T` is deeply dealiased to avoid references to local type aliases.
    */
@@ -1076,6 +1106,7 @@ trait Implicits { self: Typer =>
     if (mySpecialHandlers == null)
       mySpecialHandlers = List(
         defn.ClassTagClass        -> synthesizedClassTag,
+        defn.TypeTestClass        -> synthesizedTypeTest,
         defn.QuotedTypeClass      -> synthesizedTypeTag,
         defn.QuoteContextClass    -> synthesizedQuoteContext,
         defn.EqlClass             -> synthesizedEq,

library/src/scala/reflect/TypeTest.scala

@@ -25,3 +25,9 @@ trait TypeTest[-S, T] extends Serializable {
   def unapply(x: S): Option[x.type & T]
 
 }
+
+object TypeTest {
+
+  def identity[T]: TypeTest[T, T] = Some(_)
+
+}

tests/neg-custom-args/fatal-warnings/IsInstanceOfClassTag2.scala

@@ -14,7 +14,7 @@ object IsInstanceOfClassTag {
       case Some(xs) =>
     }
 
-    safeCast[List[_]](List[Int](1)) match { // error
+    safeCast[List[_]](List[Int](1)) match {
       case None =>
       case Some(xs) =>
     }

tests/neg-custom-args/fatal-warnings/type-test-syntesize.scala

@@ -0,0 +1,29 @@
+import scala.reflect.TypeTest
+
+object Test {
+  def test[S, T](given TypeTest[S, T]): Unit = ()
+  val a: A = ???
+
+  test[Any, Any]
+  test[Int, Int]
+
+  test[Int, Any]
+  test[String, Any]
+  test[String, AnyRef]
+
+  test[Any, Int]
+  test[Any, String]
+  test[Any, Some[_]]
+  test[Any, Array[Int]]
+  test[Seq[Int], List[Int]]
+
+  test[Any, Some[Int]] // error
+  test[Any, a.X] // error
+  test[a.X, a.Y] // error
+
+}
+
+class A {
+  type X
+  type Y <: X
+}

tests/neg/type-test-syntesize.scala

@@ -0,0 +1,19 @@
+import scala.reflect.TypeTest
+
+object Test {
+  def test[S, T](given x: TypeTest[S, T]): Unit = ()
+
+  test[Any, AnyRef] // error
+  test[Any, AnyVal] // error
+  test[Any, Object] // error
+
+  test[Any, Nothing] // error
+  test[AnyRef, Nothing] // error
+  test[AnyVal, Nothing] // error
+  test[Null, Nothing] // error
+  test[Unit, Nothing] // error
+  test[Int, Nothing] // error
+  test[8, Nothing] // error
+  test[List[_], Nothing] // error
+  test[Nothing, Nothing] // error
+}

tests/pos/type-test-syntesize.scala

@@ -0,0 +1,29 @@
+import scala.reflect.TypeTest
+
+object Test {
+  def test[S, T](given TypeTest[S, T]): Unit = ()
+  val a: A = ???
+
+  test[Any, Any]
+  test[Int, Int]
+
+  test[Int, Any]
+  test[String, Any]
+  test[String, AnyRef]
+
+  test[Any, Int]
+  test[Any, String]
+  test[Any, Some[_]]
+  test[Any, Array[Int]]
+  test[Seq[Int], List[Int]]
+
+  test[Any, Some[Int]] // unchecked warning
+  test[Any, a.X] // unchecked warning
+  test[a.X, a.Y] // unchecked warning
+
+}
+
+class A {
+  type X
+  type Y <: X
+}