fix #1354: improve type test and typecast of union types

Author: liufengyun

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

@@ -1,20 +1,18 @@
 package dotty.tools.dotc
 package transform
 
-import TreeTransforms._
-import core.Denotations._
-import core.SymDenotations._
 import core.Contexts._
 import core.Symbols._
 import core.Types._
 import core.Constants._
 import core.StdNames._
 import core.TypeErasure.isUnboundedGeneric
-import typer.ErrorReporting._
 import ast.Trees._
 import Erasure.Boxing._
 import core.TypeErasure._
 import ValueClasses._
+import core.Decorators._
+import core.Flags._
 
 /** This transform normalizes type tests and type casts,
  *  also replacing type tests with singleton argument type with reference equality check
@@ -80,7 +78,7 @@ trait TypeTestsCasts {
           }
         }
 
-        def transformAsInstanceOf(argType: Type): Tree = {
+        def transformAsInstanceOf(qual: Tree, argType: Type): Tree = {
           def argCls = argType.widen.classSymbol
           if (qual.tpe <:< argType)
             Typed(qual, tree.args.head)
@@ -92,14 +90,57 @@ trait TypeTestsCasts {
             unbox(qual.ensureConforms(defn.ObjectType), argType)
           else if (isDerivedValueClass(argCls)) {
             qual // adaptToType in Erasure will do the necessary type adaptation
-          } else
+          }
+          else
             derivedTree(qual, defn.Any_asInstanceOf, argType)
         }
-        def erasedArg = erasure(tree.args.head.tpe)
+
+        /** 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 the 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))
+        }
+
+        /** Transform asInstanceOf OrType
+         *
+         *    expr.asInstanceOf[A | B]  ~~>  try expr.asInstanceOf[A] catch {
+         *                                     case ex: Throwable => expr.asInstanceOf[B]
+         *                                   }
+         *
+         *  The transform happens before erasure of `argType`, thus cannot be merged
+         *  with the transformAsInstanceOf, which depends on erased type of `argType`.
+         */
+        def transformOrTypeCast(qual: Tree, argType: Type): Tree = argType match {
+          case OrType(tp1, tp2) =>
+            evalOnce(qual) { fun =>
+              val exName = ctx.freshName("ex").toTermName
+              val exSymbol =
+                ctx.newSymbol(ctx.owner, exName, Synthetic | Case, defn.ThrowableType, coord = tree.pos)
+
+              Try(transformOrTypeCast(fun, tp1),
+                List(CaseDef(BindTyped(exSymbol, exSymbol.info), EmptyTree, transformOrTypeCast(fun, tp2))),
+                EmptyTree)
+            }
+          case _ =>
+            transformAsInstanceOf(qual, erasure(argType))
+        }
+
         if (sym eq defn.Any_isInstanceOf)
-          transformIsInstanceOf(qual, erasedArg)
+          transformOrTypeTest(qual, tree.args.head.tpe)
         else if (sym eq defn.Any_asInstanceOf)
-          transformAsInstanceOf(erasedArg)
+          transformOrTypeCast(qual, tree.args.head.tpe)
         else tree
 
       case _ =>

tests/run/i1354.check

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

tests/run/i1354.scala

@@ -0,0 +1,30 @@
+object Test {
+  def foo(a: Int | Double) = a match {
+    case a: (Float | Boolean) => 1
+    case _ => 0
+  }
+
+  def typeTest(a: Int | Double) = a.isInstanceOf[Float | Boolean] // is it true or false?
+
+  def typeCast(a: Int | Double) = a.asInstanceOf[Float | Boolean] // is it true or false?
+
+  def main(args: Array[String]): Unit = {
+    println(foo(4))
+
+    println(typeTest(4))
+
+    try { println(typeCast(5)) }
+    catch {
+      case ex: Throwable => println("false")
+    }
+
+    Boolean.box(true) match {
+     case a: (Float | Boolean) => println(1)
+     case _ => println(0)
+    }
+
+    println(Boolean.box(true).isInstanceOf[Float | Boolean])
+
+    println(Boolean.box(true).asInstanceOf[Float | Boolean])
+  }
+}