Merge pull request #5939 from milessabin/topic/i5938

Prevent synthetic casts from blocking erasure

Author: milessabin

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

@@ -562,7 +562,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   /** Strips layers of `.asInstanceOf[T]` / `_.$asInstanceOf[T]()` from an expression */
   def stripCast(tree: Tree)(implicit ctx: Context): Tree = {
-    def isCast(sel: Tree) = sel.symbol == defn.Any_asInstanceOf
+    def isCast(sel: Tree) = sel.symbol.isTypeCast
     unsplice(tree) match {
       case TypeApply(sel @ Select(inner, _), _) if isCast(sel) =>
         stripCast(inner)

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -272,10 +272,11 @@ class Definitions {
     lazy val Any_isInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
     lazy val Any_asInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, _.paramRefs(0), Final)
     lazy val Any_typeTest: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic | Artifact)
+    lazy val Any_typeCast: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOfPM, _.paramRefs(0), Final | Synthetic | Artifact | Erased)
       // generated by pattern matcher, eliminated by erasure
 
     def AnyMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode,
-      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf, Any_typeTest)
+      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf, Any_typeTest, Any_typeCast)
 
   lazy val ObjectClass: ClassSymbol = {
     val cls = ctx.requiredClass("java.lang.Object")

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -383,6 +383,7 @@ object StdNames {
     val asType: N               = "asType"
     val asClass: N              = "asClass"
     val asInstanceOf_ : N       = "asInstanceOf"
+    val asInstanceOfPM: N       = "$asInstanceOf$"
     val assert_ : N             = "assert"
     val assume_ : N             = "assume"
     val box: N                  = "box"

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

@@ -346,7 +346,7 @@ class ReifyQuotes extends MacroTransform {
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
       reporting.trace(i"Reifier.transform $tree at $level", show = true) {
         tree match {
-          case TypeApply(Select(spliceTree @ Spliced(_), _), tp) if tree.symbol == defn.Any_asInstanceOf =>
+          case TypeApply(Select(spliceTree @ Spliced(_), _), tp) if tree.symbol.isTypeCast =>
             // Splice term which should be in the form `x.unary_~.asInstanceOf[T]` where T is an artefact of
             // typer to allow pickling/unpickling phase consistent types
             transformSplice(spliceTree)

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

@@ -46,8 +46,11 @@ class SymUtils(val self: Symbol) extends AnyVal {
   def isTypeTest(implicit ctx: Context): Boolean =
     self == defn.Any_isInstanceOf || self == defn.Any_typeTest
 
+  def isTypeCast(implicit ctx: Context): Boolean =
+    self == defn.Any_asInstanceOf || self == defn.Any_typeCast
+
   def isTypeTestOrCast(implicit ctx: Context): Boolean =
-    self == defn.Any_asInstanceOf || isTypeTest
+    isTypeCast || isTypeTest
 
   def isVolatile(implicit ctx: Context): Boolean = self.hasAnnotation(defn.VolatileAnnot)
 

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

@@ -294,7 +294,7 @@ object TypeTestsCasts {
             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 eq defn.Any_asInstanceOf)
+        else if (sym.isTypeCast)
           transformAsInstanceOf(erasure(tree.args.head.tpe))
         else tree
 

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -989,7 +989,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
                 t match {
                   case Typed(expr, _) =>
                     Block(stats, expr)
-                  case TypeApply(Select(expr, n), _) if n == defn.Any_asInstanceOf.name =>
+                  case TypeApply(sel@Select(expr, _), _) if sel.symbol.isTypeCast =>
                     Block(stats, expr)
                   case _ =>
                     rhs0

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2622,7 +2622,7 @@ class Typer extends Namer
           // I suspect, but am not 100% sure that this might affect inferred types,
           // if the expected type is a supertype of the GADT bound. It would be good to come
           // up with a test case for this.
-          tree.asInstance(pt)
+          tree.select(defn.Any_typeCast).appliedToType(pt)
         else
           tree
       }

compiler/test/dotc/pos-from-tasty.blacklist

@@ -24,3 +24,6 @@ i4006c.scala
 # Not sure what's wring here
 i4203.scala
 t6278-synth-def.scala
+
+# Need to print empty tree for implicit match
+i5938.scala

compiler/test/dotc/run-from-tasty.blacklist

@@ -12,4 +12,4 @@ typeclass-derivation2a.scala
 typeclass-derivation3.scala
 derive-generic.scala
 deriving-interesting-prefixes.scala
-
+companion-loading.scala

tests/pos/i5938.scala

@@ -0,0 +1,22 @@
+trait Link[T, A]
+
+inline def link[T] = implicit match {
+  case _: Link[T, s] =>
+    implicit match {
+      case stuff: s => stuff
+    }
+}
+
+class Foo
+object Foo {
+  erased implicit val barLink: Link[Foo, Bar.type] = null
+}
+
+implicit object Bar {
+  def baz: Unit = ()
+}
+
+object Test extends App {
+  val bar = link[Foo]
+  bar.baz
+}

tests/run/companion-loading.check

@@ -0,0 +1,5 @@
+Test
+Foo companion
+foo: Foo(23)
+FooAssoc
+assoc: 23

tests/run/companion-loading.scala

@@ -0,0 +1,40 @@
+trait Assoc[T] {
+  type U
+  def foo(t: T): U
+}
+
+trait Link[T, A]
+
+case class Foo(i: Int)
+object Foo {
+  println(s"Foo companion")
+
+  erased implicit val barLink: Link[Foo, FooAssoc.type] = null
+}
+
+implicit object FooAssoc extends Assoc[Foo] {
+  println(s"FooAssoc")
+
+  type U = Int
+  def foo(t: Foo): Int = t.i
+}
+
+inline def link[T] = implicit match {
+  case _: Link[T, s] =>
+    implicit match {
+      case stuff: s => stuff
+    }
+}
+
+object Test {
+  println(s"Test")
+
+  def main(args: Array[String]): Unit = {
+    val foo = Foo(23)
+    println(s"foo: $foo")
+
+    val assoc = link[Foo]
+    val res: Int = assoc.foo(foo)
+    println(s"assoc: ${res}")
+  }
+}