Fix #5006: Normalize prefixes of TypeApply in Erasure

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1253,15 +1253,15 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def desugarIdent(tree: Ident)(implicit ctx: Context): Tree = {
     val qual = desugarIdentPrefix(tree)
     if (qual.isEmpty) tree
-    else qual.select(tree.symbol)
+    else qual.select(tree.symbol).withSpan(tree.span)
   }
 
   /** Recover identifier prefix (e.g. this) if it exists */
   def desugarIdentPrefix(tree: Ident)(implicit ctx: Context): Tree = tree.tpe match {
     case TermRef(prefix: TermRef, _) =>
-      ref(prefix)
+      ref(prefix).withSpan(tree.span)
     case TermRef(prefix: ThisType, _) =>
-      This(prefix.cls)
+      This(prefix.cls).withSpan(tree.span)
     case _ =>
       EmptyTree
   }

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

@@ -156,159 +156,161 @@ object TypeTestsCasts {
   }
 
   def interceptTypeApply(tree: TypeApply)(implicit ctx: Context): Tree = trace(s"transforming ${tree.show}", show = true) {
-    tree.fun match {
-      case fun @ Select(expr, selector) =>
-        val sym = tree.symbol
+    val expr = tree.fun match {
+      case Select(expr, _) => expr
+      case i: Ident => desugarIdentPrefix(i)
+      case _ => EmptyTree
+    }
+    if (expr.isEmpty) tree
+    else {
+      val sym = tree.symbol
+
+      def isPrimitive(tp: Type) = tp.classSymbol.isPrimitiveValueClass
 
-        def isPrimitive(tp: Type) = tp.classSymbol.isPrimitiveValueClass
+      def derivedTree(expr1: Tree, sym: Symbol, tp: Type) =
+        cpy.TypeApply(tree)(expr1.select(sym).withSpan(expr.span), List(TypeTree(tp)))
 
-        def derivedTree(expr1: Tree, sym: Symbol, tp: Type) =
-          cpy.TypeApply(tree)(expr1.select(sym).withSpan(expr.span), List(TypeTree(tp)))
+      def effectiveClass(tp: Type): Symbol =
+        if (tp.isRef(defn.PairClass)) effectiveClass(erasure(tp))
+        else tp.classSymbol
 
-        def effectiveClass(tp: Type): Symbol =
-          if (tp.isRef(defn.PairClass)) effectiveClass(erasure(tp))
-          else tp.classSymbol
+      def foundCls = effectiveClass(expr.tpe.widen)
 
-        def foundCls = effectiveClass(expr.tpe.widen)
+      def inMatch =
+        tree.fun.symbol == defn.Any_typeTest ||  // new scheme
+        expr.symbol.is(Case)                // old scheme
 
-        def inMatch =
-          fun.symbol == defn.Any_typeTest ||  // new scheme
-          expr.symbol.is(Case)                // old scheme
+      def transformIsInstanceOf(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = {
+        def testCls = effectiveClass(testType.widen)
 
-        def transformIsInstanceOf(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = {
-          def testCls = effectiveClass(testType.widen)
+        def unreachable(why: => String): Boolean = {
+          if (flagUnrelated)
+            if (inMatch) ctx.error(em"this case is unreachable since $why", expr.sourcePos)
+            else ctx.warning(em"this will always yield false since $why", expr.sourcePos)
+          false
+        }
 
-          def unreachable(why: => String): Boolean = {
-            if (flagUnrelated)
-              if (inMatch) ctx.error(em"this case is unreachable since $why", expr.sourcePos)
-              else ctx.warning(em"this will always yield false since $why", expr.sourcePos)
+        /** Are `foundCls` and `testCls` classes that allow checks
+          *  whether a test would be always false?
+          */
+        def isCheckable =
+          foundCls.isClass && testCls.isClass &&
+          !(testCls.isPrimitiveValueClass && !foundCls.isPrimitiveValueClass) &&
+              // if `test` is primitive but `found` is not, we might have a case like
+              // found = java.lang.Integer, test = Int, which could be true
+              // (not sure why that is so, but scalac behaves the same way)
+          !isDerivedValueClass(foundCls) && !isDerivedValueClass(testCls)
+              // we don't have the logic to handle derived value classes
+
+        /** Check whether a runtime test that a value of `foundCls` can be a `testCls`
+          *  can be true in some cases. Issues a warning or an error otherwise.
+          */
+        def checkSensical: Boolean =
+          if (!isCheckable) true
+          else if (foundCls.isPrimitiveValueClass && !testCls.isPrimitiveValueClass) {
+            ctx.error("cannot test if value types are references", tree.sourcePos)
             false
           }
-
-          /** Are `foundCls` and `testCls` classes that allow checks
-           *  whether a test would be always false?
-           */
-          def isCheckable =
-            foundCls.isClass && testCls.isClass &&
-            !(testCls.isPrimitiveValueClass && !foundCls.isPrimitiveValueClass) &&
-               // if `test` is primitive but `found` is not, we might have a case like
-               // found = java.lang.Integer, test = Int, which could be true
-               // (not sure why that is so, but scalac behaves the same way)
-            !isDerivedValueClass(foundCls) && !isDerivedValueClass(testCls)
-               // we don't have the logic to handle derived value classes
-
-          /** Check whether a runtime test that a value of `foundCls` can be a `testCls`
-           *  can be true in some cases. Issues a warning or an error otherwise.
-           */
-          def checkSensical: Boolean =
-            if (!isCheckable) true
-            else if (foundCls.isPrimitiveValueClass && !testCls.isPrimitiveValueClass) {
-              ctx.error("cannot test if value types are references", tree.sourcePos)
-              false
-            }
-            else if (!foundCls.derivesFrom(testCls)) {
-              val unrelated = !testCls.derivesFrom(foundCls) && (
-                testCls.is(Final) || !testCls.is(Trait) && !foundCls.is(Trait)
-              )
-              if (foundCls.is(Final))
-                unreachable(i"$foundCls is not a subclass of $testCls")
-              else if (unrelated)
-                unreachable(i"$foundCls and $testCls are unrelated")
-              else true
-            }
+          else if (!foundCls.derivesFrom(testCls)) {
+            val unrelated = !testCls.derivesFrom(foundCls) && (
+              testCls.is(Final) || !testCls.is(Trait) && !foundCls.is(Trait)
+            )
+            if (foundCls.is(Final))
+              unreachable(i"$foundCls is not a subclass of $testCls")
+            else if (unrelated)
+              unreachable(i"$foundCls and $testCls are unrelated")
             else true
+          }
+          else true
 
-          if (expr.tpe <:< testType)
-            if (expr.tpe.isNotNull) {
-              if (!inMatch) ctx.warning(TypeTestAlwaysSucceeds(foundCls, testCls), tree.sourcePos)
-              constant(expr, Literal(Constant(true)))
-            }
-            else expr.testNotNull
-          else if (!checkSensical)
-            constant(expr, Literal(Constant(false)))
-          else if (testCls.isPrimitiveValueClass)
-            if (foundCls.isPrimitiveValueClass)
-              constant(expr, Literal(Constant(foundCls == testCls)))
-            else
-              transformIsInstanceOf(expr, defn.boxedType(testCls.typeRef), flagUnrelated)
+        if (expr.tpe <:< testType)
+          if (expr.tpe.isNotNull) {
+            if (!inMatch) ctx.warning(TypeTestAlwaysSucceeds(foundCls, testCls), tree.sourcePos)
+            constant(expr, Literal(Constant(true)))
+          }
+          else expr.testNotNull
+        else if (!checkSensical)
+          constant(expr, Literal(Constant(false)))
+        else if (testCls.isPrimitiveValueClass)
+          if (foundCls.isPrimitiveValueClass)
+            constant(expr, Literal(Constant(foundCls == testCls)))
           else
-            derivedTree(expr, defn.Any_isInstanceOf, testType)
+            transformIsInstanceOf(expr, defn.boxedType(testCls.typeRef), flagUnrelated)
+        else
+          derivedTree(expr, defn.Any_isInstanceOf, testType)
+      }
+
+      def transformAsInstanceOf(testType: Type): Tree = {
+        def testCls = testType.widen.classSymbol
+        if (expr.tpe <:< testType)
+          Typed(expr, tree.args.head)
+        else if (testCls eq defn.BoxedUnitClass) {
+          // as a special case, casting to Unit always successfully returns Unit
+          Block(expr :: Nil, Literal(Constant(()))).withSpan(expr.span)
+        }
+        else if (foundCls.isPrimitiveValueClass) {
+          if (testCls.isPrimitiveValueClass) primitiveConversion(expr, testCls)
+          else derivedTree(box(expr), defn.Any_asInstanceOf, testType)
         }
+        else if (testCls.isPrimitiveValueClass)
+          unbox(expr.ensureConforms(defn.ObjectType), testType)
+        else if (isDerivedValueClass(testCls)) {
+          expr // adaptToType in Erasure will do the necessary type adaptation
+        }
+        else if (testCls eq defn.NothingClass) {
+          // In the JVM `x.asInstanceOf[Nothing]` would throw a class cast exception except when `x eq null`.
+          // To avoid this loophole we execute `x` and then regardless of the result throw a `ClassCastException`
+          val throwCCE = Throw(New(defn.ClassCastExceptionClass.typeRef, defn.ClassCastExceptionClass_stringConstructor,
+              Literal(Constant("Cannot cast to scala.Nothing")) :: Nil))
+          Block(expr :: Nil, throwCCE).withSpan(expr.span)
+        }
+        else
+          derivedTree(expr, defn.Any_asInstanceOf, testType)
+      }
 
-        def transformAsInstanceOf(testType: Type): Tree = {
-          def testCls = testType.widen.classSymbol
-          if (expr.tpe <:< testType)
-            Typed(expr, tree.args.head)
-          else if (testCls eq defn.BoxedUnitClass) {
-            // as a special case, casting to Unit always successfully returns Unit
-            Block(expr :: Nil, Literal(Constant(()))).withSpan(expr.span)
+      /** Transform isInstanceOf OrType
+        *
+        *    expr.isInstanceOf[A | B]  ~~>  expr.isInstanceOf[A] | expr.isInstanceOf[B]
+        *    expr.isInstanceOf[A & B]  ~~>  expr.isInstanceOf[A] & expr.isInstanceOf[B]
+        *
+        *  The transform happens before erasure of `testType`, thus cannot be merged
+        *  with `transformIsInstanceOf`, which depends on erased type of `testType`.
+        */
+      def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias match {
+        case _: SingletonType =>
+          expr.isInstance(testType).withSpan(tree.span)
+        case OrType(tp1, tp2) =>
+          evalOnce(expr) { e =>
+            transformTypeTest(e, tp1, flagUnrelated = false)
+              .or(transformTypeTest(e, tp2, flagUnrelated = false))
           }
-          else if (foundCls.isPrimitiveValueClass) {
-            if (testCls.isPrimitiveValueClass) primitiveConversion(expr, testCls)
-            else derivedTree(box(expr), defn.Any_asInstanceOf, testType)
+        case AndType(tp1, tp2) =>
+          evalOnce(expr) { e =>
+            transformTypeTest(e, tp1, flagUnrelated)
+              .and(transformTypeTest(e, tp2, flagUnrelated))
           }
-          else if (testCls.isPrimitiveValueClass)
-            unbox(expr.ensureConforms(defn.ObjectType), testType)
-          else if (isDerivedValueClass(testCls)) {
-            expr // adaptToType in Erasure will do the necessary type adaptation
+        case defn.MultiArrayOf(elem, ndims) if isUnboundedGeneric(elem) =>
+          def isArrayTest(arg: Tree) =
+            ref(defn.runtimeMethodRef(nme.isArray)).appliedTo(arg, Literal(Constant(ndims)))
+          if (ndims == 1) isArrayTest(expr)
+          else evalOnce(expr) { e =>
+            derivedTree(e, defn.Any_isInstanceOf, e.tpe)
+              .and(isArrayTest(e))
           }
-          else if (testCls eq defn.NothingClass) {
-            // In the JVM `x.asInstanceOf[Nothing]` would throw a class cast exception except when `x eq null`.
-            // To avoid this loophole we execute `x` and then regardless of the result throw a `ClassCastException`
-            val throwCCE = Throw(New(defn.ClassCastExceptionClass.typeRef, defn.ClassCastExceptionClass_stringConstructor,
-                Literal(Constant("Cannot cast to scala.Nothing")) :: Nil))
-            Block(expr :: Nil, throwCCE).withSpan(expr.span)
-          }
-          else
-            derivedTree(expr, defn.Any_asInstanceOf, testType)
-        }
-
-        /** Transform isInstanceOf OrType
-         *
-         *    expr.isInstanceOf[A | B]  ~~>  expr.isInstanceOf[A] | expr.isInstanceOf[B]
-         *    expr.isInstanceOf[A & B]  ~~>  expr.isInstanceOf[A] & expr.isInstanceOf[B]
-         *
-         *  The transform happens before erasure of `testType`, thus cannot be merged
-         *  with `transformIsInstanceOf`, which depends on erased type of `testType`.
-         */
-        def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias match {
-          case _: SingletonType =>
-            expr.isInstance(testType).withSpan(tree.span)
-          case OrType(tp1, tp2) =>
-            evalOnce(expr) { e =>
-              transformTypeTest(e, tp1, flagUnrelated = false)
-                .or(transformTypeTest(e, tp2, flagUnrelated = false))
-            }
-          case AndType(tp1, tp2) =>
-            evalOnce(expr) { e =>
-              transformTypeTest(e, tp1, flagUnrelated)
-                .and(transformTypeTest(e, tp2, flagUnrelated))
-            }
-          case defn.MultiArrayOf(elem, ndims) if isUnboundedGeneric(elem) =>
-            def isArrayTest(arg: Tree) =
-              ref(defn.runtimeMethodRef(nme.isArray)).appliedTo(arg, Literal(Constant(ndims)))
-            if (ndims == 1) isArrayTest(expr)
-            else evalOnce(expr) { e =>
-              derivedTree(e, defn.Any_isInstanceOf, e.tpe)
-                .and(isArrayTest(e))
-            }
-          case _ =>
-            transformIsInstanceOf(expr, erasure(testType), flagUnrelated)
-        }
-
-        if (sym.isTypeTest) {
-          val argType = tree.args.head.tpe
-          val isTrusted = tree.hasAttachment(PatternMatcher.TrustedTypeTestKey)
-          if (!isTrusted && !checkable(expr.tpe, argType, tree.span))
-            ctx.warning(i"the type test for $argType cannot be checked at runtime", tree.sourcePos)
-          transformTypeTest(expr, tree.args.head.tpe, flagUnrelated = true)
-        }
-        else if (sym.isTypeCast)
-          transformAsInstanceOf(erasure(tree.args.head.tpe))
-        else tree
+        case _ =>
+          transformIsInstanceOf(expr, erasure(testType), flagUnrelated)
+      }
 
-      case _ =>
-        tree
+      if (sym.isTypeTest) {
+        val argType = tree.args.head.tpe
+        val isTrusted = tree.hasAttachment(PatternMatcher.TrustedTypeTestKey)
+        if (!isTrusted && !checkable(expr.tpe, argType, tree.span))
+          ctx.warning(i"the type test for $argType cannot be checked at runtime", tree.sourcePos)
+        transformTypeTest(expr, tree.args.head.tpe, flagUnrelated = true)
+      }
+      else if (sym.isTypeCast)
+        transformAsInstanceOf(erasure(tree.args.head.tpe))
+      else tree
     }
   }
 }

tests/pending/fuzzy/RE-96bd93de803119f21ab5d429b0ce0793869d86c5.scala renamed to tests/fuzzy/RE-96bd93de803119f21ab5d429b0ce0793869d86c5.scala

@@ -0,0 +1,11 @@
+object i0 {
+  def f: Int = asInstanceOf[Int].toInt
+}
+
+class i2 {
+  def f: Int = asInstanceOf[Int].toInt
+}
+
+trait i3 {
+  def f: Int = asInstanceOf[Int].toInt
+}