Merge IsInstanceOfChecker and TypeTestsCasts

It turns out it is difficult to find a good home for CutErasedDecls.
Further tests revealed it has to run after the group of ExplicitOuter,
since erased defs still need to be analyzed to see whether they require
outer references to be generated.

But it has also to run before checking whether InstanceOfs can be computed
at runtime. The only way to accommodate that is to merge IsInstanceOfChecker
with TypeTestsCasts, so that it is run at erasure. That's more coherent
and shorter anyway.

Author: odersky

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -73,15 +73,14 @@ class Compiler {
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
          new ClassOf,                // Expand `Predef.classOf` calls.
          new RefChecks) ::           // Various checks mostly related to abstract members and overriding
-    List(new CutErasedDecls,         // Drop erased definitions from scopes and simplify erased expressions
-         new TryCatchPatterns,       // Compile cases in try/catch
+    List(new TryCatchPatterns,       // Compile cases in try/catch
          new PatternMatcher,         // Compile pattern matches
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
          new StringInterpolatorOpt,  // Optimizes raw and s string interpolators by rewriting them to string concatentations
          new CrossCastAnd,           // Normalize selections involving intersection types.
          new Splitter) ::            // Expand selections involving union types into conditionals
-    List(new IsInstanceOfChecker,    // check runtime realisability for `isInstanceOf`
+    List(new CutErasedDecls,         // Drop erased definitions from scopes and simplify erased expressions
          new VCInlineMethods,        // Inlines calls to value class methods
          new SeqLiterals,            // Express vararg arguments as arrays
          new InterceptedMethods,     // Special handling of `==`, `|=`, `getClass` methods

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

@@ -25,7 +25,7 @@ class CutErasedDecls extends MiniPhase with SymTransformer { thisTransform =>
 
   override def changesMembers = true   // makes erased members private
 
-  override def runsAfterGroupsOf = Set(RefChecks.name)
+  override def runsAfterGroupsOf = Set(RefChecks.name, ExplicitOuter.name)
 
   override def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
     if (sym.is(Erased, butNot = Private) && sym.owner.isClass)

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

@@ -51,9 +51,8 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
   override def phaseName: String = ResolveSuper.name
 
   override def runsAfter = Set(ElimByName.name, // verified empirically, need to figure out what the reason is.
-                               AugmentScala2Traits.name)
-
-  override def runsAfterGroupsOf = Set(CutErasedDecls.name) // Erased decls make `isCurrent` work incorrectly
+                               AugmentScala2Traits.name,
+                               CutErasedDecls.name) // Erased decls make `isCurrent` work incorrectly
 
   override def changesMembers = true // the phase adds super accessors and method forwarders
 

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

@@ -4,6 +4,7 @@ package transform
 import core._
 import Contexts._, Symbols._, Types._, Constants._, StdNames._, Decorators._
 import ast.Trees._
+import ast.untpd
 import Erasure.Boxing._
 import TypeErasure._
 import ValueClasses._
@@ -12,7 +13,7 @@ import core.Flags._
 import util.Positions._
 import reporting.diagnostic.messages.TypeTestAlwaysSucceeds
 import reporting.trace
-
+import config.Printers.{ transforms => debug }
 
 /** This transform normalizes type tests and type casts,
  *  also replacing type tests with singleton argument type with reference equality check
@@ -21,12 +22,122 @@ import reporting.trace
  *   - have a reference type as receiver
  *   - can be translated directly to machine instructions
  *
- *
  * Unfortunately this phase ended up being not Y-checkable unless types are erased. A cast to an ConstantType(3) or x.type
- * cannot be rewritten before erasure.
+ * cannot be rewritten before erasure. That's why TypeTestsCasts is called from Erasure.
  */
 object TypeTestsCasts {
   import ast.tpd._
+  import typer.Inferencing.maximizeType
+  import typer.ProtoTypes.constrained
+
+  /** Whether `(x:X).isInstanceOf[P]` can be checked at runtime?
+   *
+   *  First do the following substitution:
+   *  (a) replace `T @unchecked` and pattern binder types (e.g., `_$1`) in P with WildcardType
+   *  (b) replace pattern binder types (e.g., `_$1`) in X:
+   *      - variance = 1  : hiBound
+   *      - variance = -1 : loBound
+   *      - variance = 0  : OrType(Any, Nothing) // TODO: use original type param bounds
+   *
+   *  Then check:
+   *
+   *  1. if `X <:< P`, TRUE
+   *  2. if `P` is a singleton type, TRUE
+   *  3. if `P` refers to an abstract type member or type parameter, FALSE
+   *  4. if `P = Array[T]`, checkable(E, T) where `E` is the element type of `X`, defaults to `Any`.
+   *  5. if `P` is `pre.F[Ts]` and `pre.F` refers to a class which is not `Array`:
+   *     (a) replace `Ts` with fresh type variables `Xs`
+   *     (b) constrain `Xs` with `pre.F[Xs] <:< X`
+   *     (c) instantiate Xs and check `pre.F[Xs] <:< P`
+   *  6. if `P = T1 | T2` or `P = T1 & T2`, checkable(X, T1) && checkable(X, T2).
+   *  7. if `P` is a refinement type, FALSE
+   *  8. otherwise, TRUE
+   */
+  def checkable(X: Type, P: Type, pos: Position)(implicit ctx: Context): Boolean = {
+    def isAbstract(P: Type) = !P.dealias.typeSymbol.isClass
+    def isPatternTypeSymbol(sym: Symbol) = !sym.isClass && sym.is(Case)
+
+    def replaceP(tp: Type)(implicit ctx: Context) = new TypeMap {
+      def apply(tp: Type) = tp match {
+        case tref: TypeRef
+        if isPatternTypeSymbol(tref.typeSymbol) => WildcardType
+        case AnnotatedType(_, annot)
+        if annot.symbol == defn.UncheckedAnnot => WildcardType
+        case _ => mapOver(tp)
+      }
+    }.apply(tp)
+
+    def replaceX(tp: Type)(implicit ctx: Context) = new TypeMap {
+      def apply(tp: Type) = tp match {
+        case tref: TypeRef
+        if isPatternTypeSymbol(tref.typeSymbol) =>
+          if (variance == 1) tref.info.hiBound
+          else if (variance == -1) tref.info.loBound
+          else OrType(defn.AnyType, defn.NothingType)
+        case _ => mapOver(tp)
+      }
+    }.apply(tp)
+
+    /** Approximate type parameters depending on variance */
+    def stripTypeParam(tp: Type)(implicit ctx: Context) = new ApproximatingTypeMap {
+      def apply(tp: Type): Type = tp match {
+        case tp: TypeRef if tp.underlying.isInstanceOf[TypeBounds] =>
+          val lo = apply(tp.info.loBound)
+          val hi = apply(tp.info.hiBound)
+          range(lo, hi)
+        case _ =>
+          mapOver(tp)
+      }
+    }.apply(tp)
+
+    def isClassDetermined(X: Type, P: AppliedType)(implicit ctx: Context) = {
+      val AppliedType(tycon, _) = P
+      val typeLambda = tycon.ensureLambdaSub.asInstanceOf[TypeLambda]
+      val tvars = constrained(typeLambda, untpd.EmptyTree, alwaysAddTypeVars = true)._2.map(_.tpe)
+      val P1 = tycon.appliedTo(tvars)
+
+      debug.println("P : " + P)
+      debug.println("P1 : " + P1)
+      debug.println("X : " + X)
+
+      P1 <:< X       // constraint P1
+
+      // use fromScala2x to avoid generating pattern bound symbols
+      maximizeType(P1, pos, fromScala2x = true)
+
+      val res = P1 <:< P
+      debug.println("P1 : " + P1)
+      debug.println("P1 <:< P = " + res)
+
+      res
+    }
+
+    def recur(X: Type, P: Type): Boolean = (X <:< P) || (P match {
+      case _: SingletonType     => true
+      case _: TypeProxy
+      if isAbstract(P)          => false
+      case defn.ArrayOf(tpT)    =>
+        X match {
+          case defn.ArrayOf(tpE)   => recur(tpE, tpT)
+          case _                   => recur(defn.AnyType, tpT)
+        }
+      case tpe: AppliedType     =>
+        // first try withou striping type parameters for performance
+        isClassDetermined(X, tpe)(ctx.fresh.setNewTyperState()) ||
+        isClassDetermined(stripTypeParam(X), tpe)(ctx.fresh.setNewTyperState())
+      case AndType(tp1, tp2)    => recur(X, tp1) && recur(X, tp2)
+      case OrType(tp1, tp2)     => recur(X, tp1) && recur(X, tp2)
+      case AnnotatedType(t, _)  => recur(X, t)
+      case _: RefinedType       => false
+      case _                    => true
+    })
+
+    val res = recur(replaceX(X.widen), replaceP(P))
+
+    debug.println(i"checking  ${X.show} isInstanceOf ${P} = $res")
+
+    res
+  }
 
   def interceptTypeApply(tree: TypeApply)(implicit ctx: Context): Tree = trace(s"transforming ${tree.show}", show = true) {
     tree.fun match {
@@ -156,8 +267,12 @@ object TypeTestsCasts {
             transformIsInstanceOf(expr, erasure(testType), flagUnrelated)
         }
 
-        if (sym.isTypeTest)
+        if (sym.isTypeTest) {
+          val argType = tree.args.head.tpe
+          if (!checkable(expr.tpe, argType, tree.pos))
+            ctx.warning(s"the type test for $argType cannot be checked at runtime", tree.pos)
           transformTypeTest(expr, tree.args.head.tpe, flagUnrelated = true)
+        }
         else if (sym eq defn.Any_asInstanceOf)
           transformAsInstanceOf(erasure(tree.args.head.tpe))
         else tree