Refine tpd.isInstance

This now special cases `x.isInstance[y.type]`
to `x eq y` and similarly for constant types.

Author: odersky

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -757,9 +757,20 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def ensureApplied(implicit ctx: Context): Tree =
       if (tree.tpe.widen.isParameterless) tree else tree.appliedToNone
 
-    /** `tree.isInstanceOf[tp]` */
-    def isInstance(tp: Type)(implicit ctx: Context): Tree =
-      tree.select(defn.Any_isInstanceOf).appliedToType(tp)
+    /** `tree == that` */
+    def equal(that: Tree)(implicit ctx: Context) =
+      applyOverloaded(tree, nme.EQ, that :: Nil, Nil, defn.BooleanType)
+
+    /** `tree.isInstanceOf[tp]`, with special treatment of singleton types */
+    def isInstance(tp: Type)(implicit ctx: Context): Tree = tp match {
+      case tp: SingletonType =>
+        if (tp.widen.derivesFrom(defn.ObjectClass))
+          tree.ensureConforms(defn.ObjectType).select(defn.Object_eq).appliedTo(singleton(tp))
+        else
+          singleton(tp).equal(tree)
+      case _ =>
+        tree.select(defn.Any_isInstanceOf).appliedToType(tp)
+    }
 
     /** tree.asInstanceOf[`tp`] */
     def asInstance(tp: Type)(implicit ctx: Context): Tree = {

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

@@ -39,8 +39,6 @@ object PatMat {
       }
     }
 
-    case class BinderInfo(rhs: Tree)
-
     val binding = mutable.Map[Symbol, AnyRef/*Tree | Node*/]()
     val nonNull = mutable.Set[Symbol]()
 
@@ -54,7 +52,6 @@ object PatMat {
       binding(sym).asInstanceOf[Node]
     }
 
-      // assert(owner ne null); assert(owner ne NoSymbol)
     def freshSym(info: Type, pos: Position, owner: Symbol = ctx.owner): TermSymbol =
       ctx.newSymbol(owner, PatMatStdBinderName.fresh(), Synthetic | Case, info, coord = pos)
 
@@ -122,12 +119,7 @@ object PatMat {
 
       def condition = expectedTp.dealias match {
         case expectedTp: SingletonType =>
-          val test =
-            if (expectedTp.widen.derivesFrom(defn.ObjectClass))
-              scrutinee.ensureConforms(defn.ObjectType).select(defn.Object_eq)
-            else
-              scrutinee.select(defn.Any_==)
-          test.appliedTo(singleton(expectedTp))
+          scrutinee.isInstance(expectedTp)
         case _ =>
           val typeTest = scrutinee.select(defn.Any_typeTest).appliedToType(tpt.tpe)
           if (outerTestNeeded) typeTest.and(outerTest) else typeTest

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

@@ -133,9 +133,7 @@ object TypeTestsCasts {
          */
         def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias match {
           case _: SingletonType =>
-            val cmpOp =
-              if (testType derivesFrom defn.AnyValClass) defn.Any_equals else defn.Object_eq
-              expr.select(cmpOp).appliedTo(singleton(testType))
+            expr.isInstance(testType).withPos(tree.pos)
           case OrType(tp1, tp2) =>
             evalOnce(expr) { e =>
               transformTypeTest(e, tp1, flagUnrelated = false)