Fix #1490: type test of union types via type alias

Author: liufengyun

src/dotty/tools/dotc/core/TypeErasure.scala

@@ -112,9 +112,10 @@ object TypeErasure {
   /** The standard erasure of a Scala type. Value classes are erased as normal classes.
    *
    *  @param tp            The type to erase.
-  */
-  def erasure(tp: Type)(implicit ctx: Context): Type =
-    erasureFn(isJava = false, semiEraseVCs = false, isConstructor = false, wildcardOK = false)(tp)(erasureCtx)
+   *  @param eraseOrType   Whether erase OrType to its lowest uppper bound
+   */
+  def erasure(tp: Type, eraseOrType: Boolean = true)(implicit ctx: Context): Type =
+    erasureFn(isJava = false, semiEraseVCs = false, isConstructor = false, wildcardOK = false)(tp, eraseOrType)(erasureCtx)
 
   /** The value class erasure of a Scala type, where value classes are semi-erased to
    *  ErasedValueType (they will be fully erased in [[ElimErasedValueType]]).
@@ -337,34 +338,34 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
    *   - For NoType or NoPrefix, the type itself.
    *   - For any other type, exception.
    */
-  private def apply(tp: Type)(implicit ctx: Context): Type = tp match {
+  private def apply(tp: Type, eraseOrType: Boolean = true)(implicit ctx: Context): Type = tp match {
     case _: ErasedValueType =>
       tp
     case tp: TypeRef =>
       val sym = tp.symbol
-      if (!sym.isClass) this(tp.info)
+      if (!sym.isClass) this(tp.info, eraseOrType)
       else if (semiEraseVCs && isDerivedValueClass(sym)) eraseDerivedValueClassRef(tp)
       else if (sym == defn.ArrayClass) apply(tp.appliedTo(TypeBounds.empty)) // i966 shows that we can hit a raw Array type.
       else eraseNormalClassRef(tp)
     case tp: RefinedType =>
       val parent = tp.parent
       if (parent isRef defn.ArrayClass) eraseArray(tp)
-      else this(parent)
+      else this(parent, eraseOrType)
     case _: TermRef | _: ThisType =>
       this(tp.widen)
     case SuperType(thistpe, supertpe) =>
-      SuperType(this(thistpe), this(supertpe))
+      SuperType(this(thistpe, eraseOrType), this(supertpe, eraseOrType))
     case ExprType(rt) =>
       defn.FunctionClass(0).typeRef
     case tp: TypeProxy =>
-      this(tp.underlying)
+      this(tp.underlying, eraseOrType)
     case AndType(tp1, tp2) =>
-      erasedGlb(this(tp1), this(tp2), isJava)
+      erasedGlb(this(tp1, eraseOrType), this(tp2, eraseOrType), isJava)
     case OrType(tp1, tp2) =>
-      ctx.typeComparer.orType(this(tp1), this(tp2), erased = true)
+      ctx.typeComparer.orType(this(tp1, eraseOrType), this(tp2, eraseOrType), erased = eraseOrType)
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
-        erasureFn(tp.isJava, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
+        erasureFn(tp.isJava, semiEraseVCs, isConstructor, wildcardOK)(tpToErase, eraseOrType)
       val formals = tp.paramTypes.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>
@@ -373,14 +374,14 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           tp.derivedMethodType(tp.paramNames, formals, rt)
       }
     case tp: PolyType =>
-      this(tp.resultType) match {
+      this(tp.resultType, eraseOrType) match {
         case rt: MethodType => rt
         case rt => MethodType(Nil, Nil, rt)
       }
     case tp @ ClassInfo(pre, cls, classParents, decls, _) =>
       if (cls is Package) tp
       else {
-        def eraseTypeRef(p: TypeRef) = this(p).asInstanceOf[TypeRef]
+        def eraseTypeRef(p: TypeRef) = this(p, eraseOrType).asInstanceOf[TypeRef]
         val parents: List[TypeRef] =
           if ((cls eq defn.ObjectClass) || cls.isPrimitiveValueClass) Nil
           else classParents.mapConserve(eraseTypeRef) match {

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

@@ -51,6 +51,19 @@ trait TypeTestsCasts {
             case _: SingletonType =>
               val cmpOp = if (argType derivesFrom defn.AnyValClass) defn.Any_equals else defn.Object_eq
               expr.select(cmpOp).appliedTo(singleton(argType))
+            case OrType(tp1, tp2) =>
+             evalOnce(qual) { fun =>
+                val erased1 = transformIsInstanceOf(fun, tp1)
+                val erased2 = transformIsInstanceOf(fun, tp2)
+                erased1 match {
+                  case Literal(Constant(true)) => erased1
+                  case _ =>
+                    erased2 match {
+                      case Literal(Constant(true)) => erased2
+                      case _ => erased1 or erased2
+                    }
+                }
+             }
             case AndType(tp1, tp2) =>
               evalOnce(expr) { fun =>
                 val erased1 = transformIsInstanceOf(fun, tp1)
@@ -93,26 +106,8 @@ trait TypeTestsCasts {
             derivedTree(qual, defn.Any_asInstanceOf, argType)
         }
 
-        /** Transform isInstanceOf OrType
-         *
-         *    expr.isInstanceOf[A | B]  ~~>  expr.isInstanceOf[A] | expr.isInstanceOf[B]
-         *
-         *  The transform happens before erasure of `argType`, thus cannot be merged
-         *  with `transformIsInstanceOf`, which depends on erased type of `argType`.
-         */
-        def transformOrTypeTest(qual: Tree, argType: Type): Tree = argType match {
-          case OrType(tp1, tp2) =>
-            evalOnce(qual) { fun =>
-              transformOrTypeTest(fun, tp1)
-                .select(nme.OR)
-                .appliedTo(transformOrTypeTest(fun, tp2))
-            }
-          case _ =>
-            transformIsInstanceOf(qual, erasure(argType))
-        }
-
         if (sym eq defn.Any_isInstanceOf)
-          transformOrTypeTest(qual, tree.args.head.tpe)
+          transformIsInstanceOf(qual, erasure(tree.args.head.tpe, false))
         else if (sym eq defn.Any_asInstanceOf)
           transformAsInstanceOf(erasure(tree.args.head.tpe))
         else tree

tests/run/i1490.check

@@ -0,0 +1,3 @@
+true
+true
+false

tests/run/i1490.scala

@@ -0,0 +1,13 @@
+class Base {
+  type T = Int | Boolean
+  def test(x: Object) = x.isInstanceOf[T]
+}
+
+object Test {
+  def main(args: Array[String]) = {
+    val b = new Base
+    println(b.test(Int.box(3)))
+    println(b.test(Boolean.box(false)))
+    println(b.test(Double.box(3.4)))
+  }
+}