fix runtime check warning for canEqual & equals of case class

Author: liufengyun

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

@@ -45,6 +45,7 @@ object Checkable {
    *
    *  1. if `P` is a singleton type, TRUE
    *  2. if `P` is WildcardType, TRUE
+   *  3. if `P = T @unchecked`, TRUE
    *  3. if `P` refers to an abstract type member, 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`:
@@ -73,16 +74,15 @@ object Checkable {
       val tvars = tycon.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
       val P1 = tycon.appliedTo(tvars)
 
-      debug.println("P1 : " + P1)
+      debug.println("P1 : " + P1.show)
       debug.println("X : " + X.widen)
 
       !(P1 <:< X.widen) || {
         // val syms = maximizeType(P1, Psym.pos, fromScala2x = false)
         isFullyDefined(P1, ForceDegree.noBottom)
         val P2   = replaceBinderMap.apply(P)
         val res  = P1 <:< P2
-        debug.println("P1: " + P1)
-        debug.println("P2: " + P2)
+        debug.println("P2: " + P2.show)
         debug.println("P1 <:< P2 = " + res)
         res
       }
@@ -99,7 +99,8 @@ object Checkable {
       case tpe: AppliedType     => !isAbstract && isClassDetermined(tpe)(ctx.fresh.setFreshGADTBounds)
       case AndType(tp1, tp2)    => checkable(X, tp1) && checkable(X, tp2)
       case OrType(tp1, tp2)     => checkable(X, tp1) && checkable(X, tp2)
-      case AnnotatedType(tp, _) => checkable(X, tp)
+      case AnnotatedType(t, an) => an.symbol == defn.UncheckedAnnot || checkable(X, t)
+      case _: RefinedType       => false
       case _                    => replaceBinderMap.apply(P) == WildcardType || !isAbstract
     }
 

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

@@ -11,6 +11,7 @@ import ast.Trees._
 import ast.untpd
 import Decorators._
 import NameOps._
+import Annotations.Annotation
 import ValueClasses.isDerivedValueClass
 import scala.collection.mutable.ListBuffer
 import scala.language.postfixOps
@@ -152,7 +153,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
      *  def equals(that: Any): Boolean =
      *    (this eq that) || {
      *      that match {
-     *        case x$0 @ (_: C) => this.x == this$0.x && this.y == x$0.y
+     *        case x$0 @ (_: C @unchecked) => this.x == this$0.x && this.y == x$0.y
      *        case _ => false
      *     }
      *  ```
@@ -162,7 +163,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
     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
       def wildcardAscription(tp: Type) = Typed(Underscore(tp), TypeTree(tp))
-      val pattern = Bind(thatAsClazz, wildcardAscription(clazzType)) // x$0 @ (_: C)
+      val pattern = Bind(thatAsClazz, wildcardAscription(AnnotatedType(clazzType, Annotation(defn.UncheckedAnnot)))) // x$0 @ (_: C @unchecked)
       val comparisons = accessors map { accessor =>
         This(clazz).select(accessor).equal(ref(thatAsClazz).select(accessor)) }
       val rhs = // this.x == this$0.x && this.y == x$0.y
@@ -250,10 +251,10 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
      *  gets the `canEqual` method
      *
      *  ```
-     *  def canEqual(that: Any) = that.isInstanceOf[C]
+     *  def canEqual(that: Any) = that.isInstanceOf[C @unchecked]
      *  ```
      */
-    def canEqualBody(that: Tree): Tree = that.isInstance(clazzType)
+    def canEqualBody(that: Tree): Tree = that.isInstance(AnnotatedType(clazzType, Annotation(defn.UncheckedAnnot)))
 
     symbolsToSynthesize flatMap syntheticDefIfMissing
   }

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

@@ -0,0 +1,20 @@
+import scala.util.control.NonFatal
+object p {
+
+  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
+}