WIP Synthesize TypeTests

Author: nicolasstucki

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

@@ -705,6 +705,43 @@ trait Implicits { self: Typer =>
         EmptyTree
     }
 
+  lazy val synthesizedTypeTest: SpecialHandler =
+    (formal, span) => implicit ctx => formal.argInfos match {
+      case arg1 :: arg2 :: Nil =>
+        (fullyDefinedType(arg1, "TypeTest argument", span), fullyDefinedType(arg2, "TypeTest argument", span)) match {
+          case (tp1, tp2) if hasStableErasure(tp2) && !defn.isBottomClass(tp2.typeSymbol) =>
+            val sym = tp2.typeSymbol
+            println()
+            println(tp1)
+            println(tp2)
+            println()
+            println()
+            // Generate: (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 cond = arg.select(defn.Any_isInstanceOf).appliedToType(arg.tpe & tp2)
+              val thenp = ref(defn.NoneModule)
+              val elsep = ref(defn.NoneModule)
+              If(cond, thenp, elsep)
+            }
+            val sam = Lambda(
+              MethodType(List(nme.s))(_ => List(tp1), mth => defn.OptionClass.typeRef.appliedTo(mth.newParamRef(0) & tp2)),
+              body
+            )
+            println(sam)
+            println(sam.show)
+            println()
+            println()
+            // TODO generate: (s: tp1) => if s.isInstanceOf[s.type & tp2] then Some(s.asInstanceOf[s.type & tp2]) else None
+            Typed(sam, TypeTree(defn.TypeTestClass.typeRef.appliedTo(tp1, tp2))).withSpan(span)
+          case _ =>
+            EmptyTree
+        }
+        EmptyTree
+      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 +1113,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 {
+
+  given [T]: TypeTest[T, T] = (s: T) => Some(s)
+
+}

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

@@ -0,0 +1,41 @@
+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, Object]
+  // 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
+
+  // test[Any, Int](given (s: Any) => if s.isInstanceOf[s.type & Int] then Some(s.asInstanceOf[s.type & Int]) else None)
+  // test[Any, String](given (s: Any) => if s.isInstanceOf[s.type & String] then Some(s.asInstanceOf[s.type & String]) else None)
+  // test[Any, Object](given (s: Any) => if s.isInstanceOf[s.type & Object] then Some(s.asInstanceOf[s.type & Object]) else None)
+  // test[Any, Some[_]](given (s: Any) => if s.isInstanceOf[s.type & Some[_]] then Some(s.asInstanceOf[s.type & Some[_]]) else None)
+  // test[Any, Array[Int]](given (s: Any) => if s.isInstanceOf[s.type & Array[Int]] then Some(s.asInstanceOf[s.type & Array[Int]]) else None)
+  // test[Seq[Int], List[Int]](given (s: Seq[Int]) => if s.isInstanceOf[s.type & List[Int]] then Some(s.asInstanceOf[s.type & List[Int]]) else None)
+
+  // test[Any, Some[Int]](given (s: Any) => if s.isInstanceOf[s.type & Some[Int]] then Some(s.asInstanceOf[s.type & Some[Int]]) else None)
+  // test[Any, a.X](given (s: Any) => if s.isInstanceOf[s.type & a.X] then Some(s.asInstanceOf[s.type & a.X]) else None)
+  // test[a.X, a.Y](given (s: a.X) => if s.isInstanceOf[s.type & a.Y] then Some(s.asInstanceOf[s.type & a.Y]) else None)
+
+}
+
+class A {
+  type X
+  type Y <: X
+}