Check that no references to erased classes survive

Author: odersky

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

@@ -584,9 +584,14 @@ object Erasure {
           case _ => // OK
         }
       }
-      tree
+      checkNotErasedClass(tree)
     }
 
+    private def checkNotErasedClass(tree: Tree)(using Context): tree.type =
+      if tree.tpe.widen.isErasedClass then
+        report.error(em"illegal reference to erased ${tree.tpe.widen.typeSymbol} in expression that is not itself erased", tree.srcPos)
+      tree
+
     def erasedDef(sym: Symbol)(using Context): Thicket = {
       if (sym.owner.isClass) sym.dropAfter(erasurePhase)
       tpd.EmptyTree
@@ -609,7 +614,7 @@ object Erasure {
      *  are handled separately by [[typedDefDef]], [[typedValDef]] and [[typedTyped]].
      */
     override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(using Context): TypeTree =
-      tree.withType(erasure(tree.tpe))
+      checkNotErasedClass(tree.withType(erasure(tree.tpe)))
 
     /** This override is only needed to semi-erase type ascriptions */
     override def typedTyped(tree: untpd.Typed, pt: Type)(using Context): Tree =
@@ -628,7 +633,7 @@ object Erasure {
       if (tree.typeOpt.isRef(defn.UnitClass))
         tree.withType(tree.typeOpt)
       else if (tree.const.tag == Constants.ClazzTag)
-        clsOf(tree.const.typeValue)
+        checkNotErasedClass(clsOf(tree.const.typeValue))
       else
         super.typedLiteral(tree)
 
@@ -996,6 +1001,9 @@ object Erasure {
       adaptClosure(implClosure)
     }
 
+    override def typedNew(tree: untpd.New, pt: Type)(using Context): Tree =
+      checkNotErasedClass(super.typedNew(tree, pt))
+
     override def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree =
       EmptyTree
 

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

@@ -21,6 +21,9 @@ object TypeUtils {
     def isPrimitiveValueType(using Context): Boolean =
       self.classSymbol.isPrimitiveValueClass
 
+    def isErasedClass(using Context): Boolean =
+      self.underlyingClassRef(refinementOK = true).typeSymbol.is(Flags.Erased)
+
     def isByName: Boolean =
       self.isInstanceOf[ExprType]
 

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

@@ -1159,7 +1159,7 @@ class Typer extends Namer
       case AppliedTypeTree(tycon: TypeTree, args)
       if !isErased
          && numArgs > 0
-         && args.indexWhere(arg => !isErasedClass(arg.tpe)) == numArgs =>
+         && args.indexWhere(!_.tpe.isErasedClass) == numArgs =>
         val tycon1 = TypeTree(defn.FunctionClass(numArgs, isContextual, isErased = true).typeRef)
           .withSpan(tycon.span)
         assignType(cpy.AppliedTypeTree(app)(tycon1, args), tycon1, args)
@@ -2175,16 +2175,13 @@ class Typer extends Namer
       //todo: make sure dependent method types do not depend on implicits or by-name params
   }
 
-  private def isErasedClass(tpe: Type)(using Context): Boolean =
-    tpe.underlyingClassRef(refinementOK = true).typeSymbol.is(Erased)
-
   /** (1) Check that the signature of the class mamber does not return a repeated parameter type
    *  (2) If info is an erased class, set erased flag of member
    */
   private def postProcessInfo(sym: Symbol)(using Context): Unit =
     if (!sym.isOneOf(Synthetic | InlineProxy | Param) && sym.info.finalResultType.isRepeatedParam)
       report.error(em"Cannot return repeated parameter type ${sym.info.finalResultType}", sym.srcPos)
-    if !sym.is(Module) && isErasedClass(sym.info) then
+    if !sym.is(Module) && sym.info.isErasedClass then
       sym.setFlag(Erased)
 
   def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = {

tests/neg/safeThrowsStrawman2.scala

@@ -0,0 +1,33 @@
+import language.experimental.erasedTerms
+
+object scalax:
+  erased class CanThrow[E <: Exception]
+  type CTF = CanThrow[Fail]
+
+  infix type throws[R, E <: Exception] = CanThrow[E] ?=> R
+
+  class Fail extends Exception
+
+  def raise[E <: Exception](e: E): Nothing throws E = throw e
+
+import scalax._
+
+def foo(x: Boolean, y: CanThrow[Fail]): Int throws Fail =
+  if x then 1 else raise(Fail())
+
+def bar(x: Boolean)(using CanThrow[Fail]): Int =
+  if x then 1 else raise(Fail())
+
+@main def Test =
+  try
+    given ctf: CanThrow[Fail] = ???
+    val x = CanThrow[Fail]()      // OK, x is erased
+    val y: Any = CanThrow[Fail]() // error: illegal reference to erased class CanThrow
+    val y2: Any = new CTF()       // error: illegal reference to erased class CanThrow
+    println(foo(true, ctf))       // error: ctf is declared as erased, but is in fact used
+    val a = (1, CanThrow[Fail]()) // error: illegal reference to erased class CanThrow
+    def b: (Int, CanThrow[Fail]) = ???
+    def c = b._2                  // ok; we only check creation sites
+    bar(true)(using ctf)
+  catch case ex: Fail =>
+    println("failed")

tests/run/safeThrowsStrawman.scala

@@ -19,7 +19,7 @@ def bar(x: Boolean)(using CanThrow[Fail]): Int =
 
 @main def Test =
   try
-    erased given CanThrow[Fail] = ???
+    given CanThrow[Fail] = ???
     println(foo(true))
     println(foo(false))
   catch case ex: Fail =>