address review and add more tests

Author: liufengyun

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

@@ -4,9 +4,10 @@ package transform
 import util.Positions._
 import MegaPhase.MiniPhase
 import core._
-import Contexts.Context, Types._, Decorators._, Symbols._, typer._, ast._
+import Contexts.Context, Types._, Decorators._, Symbols._, typer._, ast._, NameKinds._, StdNames._
 import TypeUtils._, Flags._
 import config.Printers.{ transforms => debug }
+import collection.mutable.Map
 
 /** Check runtime realizability of type test, see the documentation for `Checkable`.
  */
@@ -16,9 +17,24 @@ class IsInstanceOfChecker extends MiniPhase {
 
   val phaseName = "isInstanceOfChecker"
 
-  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree = {
+  override def transformTemplate(tree: Template)(implicit ctx: Context): Tree = {
+    // remap to cancel effect of GADT narrowing
+    val binders = Map.empty[Symbol, Symbol]
+
+    new TreeTraverser() {
+      override def traverse(tree: Tree)(implicit ctx: Context): Unit =
+        tree match {
+          case t: TypeApply => checkInstanceOf(t, binders)
+          case _            => traverseChildren(tree)
+        }
+    }.traverse(tree)
+
+    tree
+  }
+
+  def checkInstanceOf(tree: TypeApply, binders: Map[Symbol, Symbol])(implicit ctx: Context): Tree = {
     def ensureCheckable(qual: Tree, pt: Tree): Tree = {
-      if (!Checkable.checkable(qual.tpe, pt.tpe))
+      if (!Checkable.checkable(qual.tpe, pt.tpe, binders, tree.pos))
          ctx.warning(
            s"the type test for ${pt.show} cannot be checked at runtime",
            tree.pos
@@ -43,12 +59,7 @@ object Checkable {
 
   /** 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
+   *  First cancel the effect of GADT bound narrowing with the map `binders`.
    *
    *  Then check:
    *
@@ -58,13 +69,14 @@ object Checkable {
    *  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` (may fail)
+   *     (b) constrain `Xs` with `pre.F[Xs] <:< X`,
+   *         if `X` cannot be uniquely determined, instantiate `X` with fresh type symbol.
    *     (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)(implicit ctx: Context): Boolean = {
+  def checkable(X: Type, P: Type, binders: Map[Symbol, Symbol], pos: Position)(implicit ctx: Context): Boolean = {
     def isAbstract(P: Type) = !P.dealias.typeSymbol.isClass
 
     def replaceP(implicit ctx: Context) = new TypeMap {
@@ -88,6 +100,40 @@ object Checkable {
       }
     }
 
+    def replace(implicit ctx: Context) = new TypeMap {
+      def mapTypeBoundSymbol(tp: Type, paramInfo: Type): Type = tp match {
+        case tref: TypeRef
+        if !tref.typeSymbol.isClass && tref.symbol.is(Case) =>
+          if (binders.contains(tref.typeSymbol))
+            binders(tref.typeSymbol).typeRef
+          else if (tref.typeSymbol.name == tpnme.WILDCARD)
+            WildcardType
+          else {
+            val fresh = ctx.newSymbol(ctx.owner, WildcardParamName.fresh().toTypeName, Case, paramInfo.bounds, coord = pos)
+            binders(tref.typeSymbol) = fresh
+            WildcardType(paramInfo.bounds)
+          }
+        case _ =>
+          apply(tp)
+      }
+
+      def apply(tp: Type) = tp match {
+        case tapp @ AppliedType(tycon, args) =>
+          val args2 = args.zip(tycon.typeParams).map { case (arg, paramInfo) => mapTypeBoundSymbol(arg, paramInfo.paramInfo) }
+          tycon.appliedTo(args2)
+        case tref: TypeRef if !tref.typeSymbol.isClass && tref.symbol.is(Case) =>
+          if (binders.contains(tref.typeSymbol))
+            binders(tref.typeSymbol).typeRef
+          else
+            // annotation for Array[_] could reach here
+            tref
+        case AnnotatedType(_, annot) if annot.symbol == defn.UncheckedAnnot =>
+          WildcardType
+        case _ =>
+          mapOver(tp)
+      }
+    }
+
     def isClassDetermined(X: Type, P: AppliedType)(implicit ctx: Context) = {
       val AppliedType(tycon, _) = P
       val typeLambda = tycon.ensureHK.asInstanceOf[TypeLambda]
@@ -100,7 +146,17 @@ object Checkable {
 
       P1 <:< X  // may fail, ignore
 
-      val res  = isFullyDefined(P1, ForceDegree.noBottom) && P1 <:< P
+      tvars.foreach { case tvar: TypeVar =>
+        val bounds = ctx.typerState.constraint.entry(tvar.origin)
+        if (bounds.loBound =:= bounds.hiBound)
+          tvar.instantiateWith(bounds.loBound)
+        else {
+          val wildCard = ctx.newSymbol(ctx.owner, WildcardParamName.fresh().toTypeName, Case, tvar.origin.underlying, coord = pos)
+          tvar.instantiateWith(wildCard.typeRef)
+        }
+      }
+
+      val res = P1 <:< P
       debug.println("P1 : " + P1)
       debug.println("P1 <:< P = " + res)
 
@@ -119,12 +175,20 @@ object Checkable {
       case tpe: AppliedType     => isClassDetermined(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, an) => recur(X, t)
+      case AnnotatedType(t, _)  => recur(X, t)
       case _: RefinedType       => false
       case _                    => true
     })
 
-    val res = recur(replaceX.apply(X.widen), replaceP.apply(P))
+    debug.println(s"$X <: $P")
+
+    val X1 = replace.apply(X.widen)
+    val P1 = replace.apply(P)
+
+    debug.println(s"$X ~~> $X1")
+    debug.println(s"$P ~~> $P1")
+
+    val res = recur(X1, P1)
 
     debug.println(i"checking  ${X.show} isInstanceOf ${P} = $res")
 

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

@@ -159,6 +159,9 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
      *  ```
      *
      *  If `C` is a value class the initial `eq` test is omitted.
+     *
+     *  `@unchecked` is needed for parametric case classes.
+     *
      */
     def equalsBody(that: Tree)(implicit ctx: Context): Tree = {
       val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.pos) // x$0
@@ -253,6 +256,8 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
      *  ```
      *  def canEqual(that: Any) = that.isInstanceOf[C @unchecked]
      *  ```
+     *
+     *  `@unchecked` is needed for parametric case classes.
      */
     def canEqualBody(that: Tree): Tree = that.isInstance(AnnotatedType(clazzType, Annotation(defn.UncheckedAnnot)))
 

tests/neg-custom-args/isInstanceOf/3324g.scala

@@ -0,0 +1,19 @@
+class Test {
+  trait A[+T]
+  class B[T] extends A[T]
+  class C[T] extends B[Any] with A[T]
+
+  def foo[T](c: C[T]): Unit = c match {
+    case _: B[T] => // error
+  }
+
+  def bar[T](b: B[T]): Unit = b match {
+    case _: A[T] =>
+  }
+
+  def quux[T](a: A[T]): Unit = a match {
+    case _: B[T] => // error
+  }
+
+  quux(new C[Int])
+}

tests/neg-custom-args/isInstanceOf/4075.scala

@@ -0,0 +1,22 @@
+object Test {
+  trait Foo
+  case class One[+T](fst: T)
+
+  def bad[T <: Foo](e: One[T])(x: T) = e match {
+    case foo: One[a] =>
+      x.isInstanceOf[a]  // error
+      val y: Any = ???
+      y.isInstanceOf[a]  // error
+  }
+}
+
+object Test2 {
+  case class One[T](fst: T)
+
+  def bad[T](e: One[T])(x: T) = e match {
+    case foo: One[a] =>
+      x.isInstanceOf[a] // error
+      val y: Any = ???
+      y.isInstanceOf[a] // error
+  }
+}

tests/neg-custom-args/isInstanceOf/Result.scala

@@ -1,20 +1,11 @@
-import scala.util.control.NonFatal
 object p {
 
+  // test parametric case classes, which synthesis `canEqual` and `equals`
   enum Result[+T, +E] {
     case OK [T](x: T) extends Result[T, Nothing]
     case Err[E](e: E) extends Result[Nothing, E]
   }
 
-  type Try[T] = Result[T, Throwable]
-  object Try {
-    def apply[T](x: => T): Try[T] =
-      try Result.OK(x)
-      catch {
-        case NonFatal(ex) => Result.Err(ex)
-      }
-  }
-
   def foo(x: Any): Boolean =
     x.isInstanceOf[List[String]]  // error
 }