Drop erased class

odersky · odersky · commit 5be177d7211f · 2025-07-15T11:47:07.000+02:00
Replace with test whether a type derivesFrom Erased.
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -266,6 +266,7 @@ class Definitions {
     @tu lazy val CompiletimeOpsDoubleModuleClass: Symbol = requiredModule("scala.compiletime.ops.double").moduleClass
     @tu lazy val CompiletimeOpsStringModuleClass: Symbol = requiredModule("scala.compiletime.ops.string").moduleClass
     @tu lazy val CompiletimeOpsBooleanModuleClass: Symbol = requiredModule("scala.compiletime.ops.boolean").moduleClass
+  @tu lazy val ErasedClass: ClassSymbol = requiredClass("scala.compiletime.Erased")
 
   /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter)
    *  because after erasure the Any and AnyVal references get remapped to the Object methods
@@ -1015,7 +1016,7 @@ class Definitions {
     @tu lazy val Caps_Mutable: ClassSymbol = requiredClass("scala.caps.Mutable")
     @tu lazy val Caps_SharedCapability: ClassSymbol = requiredClass("scala.caps.SharedCapability")
 
-  @tu lazy val PureClass: Symbol = requiredClass("scala.Pure")
+  @tu lazy val PureClass: ClassSymbol = requiredClass("scala.Pure")
 
   // Annotation base classes
   @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
diff --git a/compiler/src/dotty/tools/dotc/core/TypeUtils.scala b/compiler/src/dotty/tools/dotc/core/TypeUtils.scala
@@ -23,11 +23,6 @@ class TypeUtils:
     def isPrimitiveValueType(using Context): Boolean =
       self.classSymbol.isPrimitiveValueClass
 
-    def isErasedClass(using Context): Boolean =
-      val cls = self.underlyingClassRef(refinementOK = true).typeSymbol
-      cls.is(Flags.Erased)
-
-
     /** Is this type a checked exception? This is the case if the type
      *  derives from Exception but not from RuntimeException. According to
      *  that definition Throwable is unchecked. That makes sense since you should
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -275,7 +275,7 @@ object Types extends TypeUtils {
         tp.isBottomType
         && (tp.hasClassSymbol(defn.NothingClass)
             || cls != defn.NothingClass && !cls.isValueClass)
-      def loop(tp: Type): Boolean = tp match {
+      def loop(tp: Type): Boolean = try tp match
         case tp: TypeRef =>
           val sym = tp.symbol
           if (sym.isClass) sym.derivesFrom(cls) else loop(tp.superType)
@@ -301,7 +301,7 @@ object Types extends TypeUtils {
           cls == defn.ObjectClass
         case _ =>
           false
-      }
+      catch case ex: Throwable => handleRecursive(i"derivesFrom $cls:", show, ex)
       loop(this)
     }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -579,8 +579,7 @@ object Erasure {
                     |it should have been processed and eliminated during expansion of an enclosing macro or term erasure."""
             report.error(message, tree.srcPos)
           case _ => // OK
-
-      checkNotErasedClass(tree)
+      tree
     end checkNotErased
 
     def checkPureErased(tree: untpd.Tree, isArgument: Boolean, isImplicit: Boolean = false)(using Context): Unit =
@@ -589,21 +588,6 @@ object Erasure {
         if !tpd.isPureExpr(tree1) then
           report.error(ErasedNotPure(tree1, isArgument, isImplicit), tree1.srcPos)
 
-    private def checkNotErasedClass(tp: Type, tree: untpd.Tree)(using Context): Unit = tp match
-      case JavaArrayType(et) =>
-        checkNotErasedClass(et, tree)
-      case _ =>
-        if tp.isErasedClass then
-          val (kind, tree1) = tree match
-            case tree: untpd.ValOrDefDef => ("definition", tree.tpt)
-            case tree: untpd.DefTree => ("definition", tree)
-            case _ => ("expression", tree)
-          report.error(em"illegal reference to erased ${tp.typeSymbol} in $kind that is not itself erased", tree1.srcPos)
-
-    private def checkNotErasedClass(tree: Tree)(using Context): tree.type =
-      checkNotErasedClass(tree.tpe.widen.finalResultType, tree)
-      tree
-
     def erasedDef(sym: Symbol)(using Context): Tree =
       if sym.isClass then
         // We cannot simply drop erased classes, since then they would not generate classfiles
@@ -631,7 +615,7 @@ object Erasure {
      *  are handled separately by [[typedDefDef]], [[typedValDef]] and [[typedTyped]].
      */
     override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(using Context): TypeTree =
-      checkNotErasedClass(tree.withType(erasure(tree.typeOpt)))
+      tree.withType(erasure(tree.typeOpt))
 
     /** This override is only needed to semi-erase type ascriptions */
     override def typedTyped(tree: untpd.Typed, pt: Type)(using Context): Tree =
@@ -650,7 +634,7 @@ object Erasure {
       if (tree.typeOpt.isRef(defn.UnitClass))
         tree.withType(tree.typeOpt)
       else if (tree.const.tag == Constants.ClazzTag)
-        checkNotErasedClass(clsOf(tree.const.typeValue))
+        clsOf(tree.const.typeValue)
       else
         super.typedLiteral(tree)
 
@@ -932,7 +916,6 @@ object Erasure {
         checkPureErased(vdef.rhs, isArgument = false)
         erasedDef(sym)
       else trace(i"erasing $vdef"):
-        checkNotErasedClass(sym.info, vdef)
         super.typedValDef(untpd.cpy.ValDef(vdef)(
           tpt = untpd.TypedSplice(TypeTree(sym.info).withSpan(vdef.tpt.span))), sym)
 
@@ -944,7 +927,6 @@ object Erasure {
       if sym.isEffectivelyErased || sym.name.is(BodyRetainerName) then
         erasedDef(sym)
       else
-        checkNotErasedClass(sym.info.finalResultType, ddef)
         val restpe = if sym.isConstructor then defn.UnitType else sym.info.resultType
         var vparams = outerParamDefs(sym)
             ::: ddef.paramss.collect {
@@ -1063,9 +1045,6 @@ 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
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -682,10 +682,9 @@ object Checking {
     if sym.isUpdateMethod && !sym.owner.derivesFrom(defn.Caps_Mutable) then
       fail(em"Update methods can only be used as members of classes extending the `Mutable` trait")
     val unerasable =
-      sym.is(Lazy, butNot = Given)
-      || sym.is(Method, butNot = Macro)
+      sym.is(Method, butNot = Macro)
       || sym.is(Mutable)
-      || sym.isType && !sym.isClass
+      || sym.isType
     checkApplicable(Erased, !unerasable)
     checkCombination(Final, Open)
     checkCombination(Sealed, Open)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1761,24 +1761,26 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       if (mt.isParamDependent)
         report.error(em"$mt is an illegal function type because it has inter-parameter dependencies", tree.srcPos)
       // Restart typechecking if there are erased classes that we want to mark erased
-      if mt.paramErasureStatuses.zip(mt.paramInfos.map(_.isErasedClass)).exists((paramErased, classErased) => classErased && !paramErased) then
-        val newParams = params2.zipWithConserve(mt.paramInfos.map(_.isErasedClass)) { (arg, isErasedClass) =>
-          if isErasedClass then arg.withAddedFlags(Erased) else arg
-        }
-        return typedDependent(newParams, result)
-      val core =
-        if mt.hasErasedParams then TypeTree(defn.PolyFunctionClass.typeRef)
-        else
-          val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(result.span)
-          val paramTpts = appDef.termParamss.head.map(p => TypeTree(p.tpt.tpe).withSpan(p.tpt.span))
-          val funSym = defn.FunctionSymbol(numArgs, isContextual)
-          val tycon = TypeTree(funSym.typeRef)
-          AppliedTypeTree(tycon, paramTpts :+ resTpt)
-      val res = RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
-      if isImpure then
-        typed(untpd.makeRetaining(untpd.TypedSplice(res), Nil, tpnme.retainsCap), pt)
+      if mt.paramErasureStatuses.lazyZip(mt.paramInfos).exists: (paramErased, info) =>
+        !paramErased && info.derivesFrom(defn.ErasedClass)
+      then
+        val newParams = params2.zipWithConserve(mt.paramInfos): (param, info) =>
+          if info.derivesFrom(defn.ErasedClass) then param.withAddedFlags(Erased) else param
+        typedDependent(newParams, result)
       else
-        res
+        val core =
+          if mt.hasErasedParams then TypeTree(defn.PolyFunctionClass.typeRef)
+          else
+            val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(result.span)
+            val paramTpts = appDef.termParamss.head.map(p => TypeTree(p.tpt.tpe).withSpan(p.tpt.span))
+            val funSym = defn.FunctionSymbol(numArgs, isContextual)
+            val tycon = TypeTree(funSym.typeRef)
+            AppliedTypeTree(tycon, paramTpts :+ resTpt)
+        val res = RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
+        if isImpure then
+          typed(untpd.makeRetaining(untpd.TypedSplice(res), Nil, tpnme.retainsCap), pt)
+        else
+          res
     end typedDependent
 
     args match {
@@ -1802,7 +1804,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           val funTpt = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ result), pt)
           // if there are any erased classes, we need to re-do the typecheck.
           funTpt match
-            case r: AppliedTypeTree if r.args.exists(_.tpe.isErasedClass) =>
+            case r: AppliedTypeTree if r.args.init.exists(_.tpe.derivesFrom(defn.ErasedClass)) =>
               typedFunctionType(desugar.makeFunctionWithValDefs(tree, pt), pt)
             case _ => funTpt
     }
@@ -2948,6 +2950,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     completeAnnotations(vdef, sym)
     if sym.is(Implicit) then checkImplicitConversionDefOK(sym)
     if sym.is(Module) then checkNoModuleClash(sym)
+    else if sym.info.derivesFrom(defn.ErasedClass) then
+      sym.setFlag(Erased)
     val tpt1 = checkSimpleKinded(typedType(tpt))
     val rhs1 = vdef.rhs match
       case rhs @ Ident(nme.WILDCARD) =>
@@ -3072,16 +3076,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   /** (1) Check that the signature of the class member does not return a repeated parameter type
-   *  (2) If info is an erased class, set erased flag of member
-   *  (3) Check that erased classes are not parameters of polymorphic functions.
-   *  (4) Make sure the definition's symbol is `sym`.
-   *  (5) Set the `defTree` of `sym` to be `mdef`.
+   *  (2) Make sure the definition's symbol is `sym`.
+   *  (3) Set the `defTree` of `sym` to be `mdef`.
    */
   private def postProcessInfo(mdef: MemberDef, sym: Symbol)(using Context): MemberDef =
     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) && !sym.isConstructor && sym.info.finalResultType.isErasedClass then
-      sym.setFlag(Erased)
     mdef.ensureHasSym(sym)
     mdef.setDefTree
 
diff --git a/library/src/scala/CanThrow.scala b/library/src/scala/CanThrow.scala
@@ -8,7 +8,7 @@ import annotation.{implicitNotFound, experimental, capability}
  */
 @experimental
 @implicitNotFound("The capability to throw exception ${E} is missing.\nThe capability can be provided by one of the following:\n - Adding a using clause `(using CanThrow[${E}])` to the definition of the enclosing method\n - Adding `throws ${E}` clause after the result type of the enclosing method\n - Wrapping this piece of code with a `try` block that catches ${E}")
-erased class CanThrow[-E <: Exception] extends caps.SharedCapability
+class CanThrow[-E <: Exception] extends caps.SharedCapability, compiletime.Erased
 
 @experimental
 object unsafeExceptions:
diff --git a/library/src/scala/Precise.scala b/library/src/scala/Precise.scala
@@ -7,5 +7,5 @@ import language.experimental.erasedDefinitions
  *  in precise mode. This means that singleton types and union types are not
  *  widened.
  */
-@experimental erased trait Precise:
+@experimental trait Precise extends compiletime.Erased:
   type Self
diff --git a/tests/invalid/neg/erased-inheritance.scala b/tests/invalid/neg/erased-inheritance.scala
diff --git a/tests/invalid/neg/safeThrowsStrawman2.scala b/tests/invalid/neg/safeThrowsStrawman2.scala
@@ -1,7 +1,7 @@
 import language.experimental.erasedDefinitions
 
 object scalax:
-  erased class CanThrow[E <: Exception]
+  class CanThrow[E <: Exception] extends compiletime.Erased
   type CTF = CanThrow[Fail]
 
   infix type raises[R, E <: Exception] = CanThrow[E] ?=> R
diff --git a/tests/neg-custom-args/captures/erased-methods2.scala b/tests/neg-custom-args/captures/erased-methods2.scala
@@ -6,7 +6,7 @@ class Ex1 extends Exception("Ex1")
 class Ex2 extends Exception("Ex2")
 class Ex3 extends Exception("Ex3")
 
-erased class CT[-E <: Exception] extends caps.Capability
+class CT[-E <: Exception] extends caps.Capability, compiletime.Erased
 
 def Throw[Ex <: Exception](ex: Ex)(using CT[Ex]^): Nothing = ???
 
diff --git a/tests/neg/erased-class.scala b/tests/neg/erased-class.scala
@@ -1,10 +1,10 @@
 import language.experimental.erasedDefinitions
 import scala.annotation.compileTimeOnly
-erased class AA
-erased class BB extends AA // ok
+class AA extends compiletime.Erased
+class BB extends AA // ok
 
 @main def Test =
-  val f1: Array[AA] = caps.unsafe.unsafeErasedValue // error // error
-  def f2(x: Int): Array[AA] = caps.unsafe.unsafeErasedValue // error // error
-  def bar: AA = caps.unsafe.unsafeErasedValue  // ok
+  val f1: Array[AA] = caps.unsafe.unsafeErasedValue // error
+  def f2(x: Int): Array[AA] = caps.unsafe.unsafeErasedValue // error
+  def bar: AA = caps.unsafe.unsafeErasedValue  // error
   val baz: AA = caps.unsafe.unsafeErasedValue // ok
diff --git a/tests/neg/i20317a.scala b/tests/neg/i20317a.scala
@@ -1,5 +1,5 @@
 type SemigroupStructural[A] =
   A & { def combine(a: A): A }
 def combineAll[A <: SemigroupStructural[A]](
-  i: A, l: List[A]
+  i: A, l: List[A]  // error
 ): A = l.foldLeft(i)(_.combine(_)) // error
diff --git a/tests/neg/lambda-infer.scala b/tests/neg/lambda-infer.scala
@@ -2,7 +2,7 @@
 
 type F = (x: Int, erased y: Int) => Int
 
-erased class A
+class A extends compiletime.Erased
 
 @main def Test() =
   val a: F = (x, y) => x + 1 // error: Expected F got (Int, Int) => Int
diff --git a/tests/neg/safeThrowsStrawman.scala b/tests/neg/safeThrowsStrawman.scala
@@ -3,7 +3,7 @@ import annotation.implicitNotFound
 
 object scalax:
   @implicitNotFound("The capability to throw exception ${E} is missing.\nThe capability can be provided by one of the following:\n - A using clause `(using CanThrow[${E}])`\n - A raises clause in a result type such as `X raises ${E}`\n - an enclosing `try` that catches ${E}")
-  erased class CanThrow[-E <: Exception]
+  class CanThrow[-E <: Exception] extends compiletime.Erased
 
   infix type raises[R, +E <: Exception] = CanThrow[E] ?=> R
 
diff --git a/tests/pos/erased-class-as-args.scala b/tests/pos/erased-class-as-args.scala
@@ -1,8 +1,8 @@
-//> using options -language:experimental.erasedDefinitions
+import language.experimental.erasedDefinitions
 
-erased class A
+class A extends compiletime.Erased
 
-erased class B(val x: Int) extends A
+class B(val x: Int) extends A
 
 type T = (x: A, y: Int) => Int
 
diff --git a/tests/pos/erased-class-separate/A_1.scala b/tests/pos/erased-class-separate/A_1.scala
@@ -1,3 +1,3 @@
 import language.experimental.erasedDefinitions
-erased class A
+class A extends compiletime.Erased
 
diff --git a/tests/pos/erased-conforms.scala b/tests/pos/erased-conforms.scala
@@ -1,9 +1,9 @@
 import language.experimental.erasedDefinitions
-erased class ErasedTerm
+class ErasedTerm extends compiletime.Erased
 
-erased class <::<[-From, +To] extends ErasedTerm
+class <::<[-From, +To] extends ErasedTerm
 
-erased class =::=[From, To] extends (From <::< To)
+class =::=[From, To] extends (From <::< To)
 
 inline given [X] => (X =::= X) = scala.caps.unsafe.unsafeErasedValue
 
diff --git a/tests/pos/erased-lazy-val.scala b/tests/pos/erased-lazy-val.scala
@@ -1,5 +1,5 @@
 //> using options -language:experimental.erasedDefinitions
 
 object Test {
-  erased lazy val i: Int = 1 // error
+  erased lazy val i: Int = 1 // now OK
 }
diff --git a/tests/pos/experimental-erased-2.scala b/tests/pos/experimental-erased-2.scala
@@ -3,6 +3,6 @@ import annotation.experimental
 
 @experimental object Test:
 
-  erased class CanThrow[-E <: Exception]
+  class CanThrow[-E <: Exception] extends compiletime.Erased
 
   def other = 1
diff --git a/tests/pos/experimental-erased.scala b/tests/pos/experimental-erased.scala
@@ -2,7 +2,7 @@ import language.experimental.erasedDefinitions
 import annotation.experimental
 
 @experimental
-erased class CanThrow[-E <: Exception](val i: Int = 0)
+class CanThrow[-E <: Exception](val i: Int = 0) extends compiletime.Erased
 
 @experimental
 object Foo
diff --git a/tests/pos/experimentalErased.scala b/tests/pos/experimentalErased.scala
@@ -2,9 +2,9 @@ import language.experimental.erasedDefinitions
 import annotation.experimental
 
 @experimental
-erased class Foo
+class Foo extends compiletime.Erased
 
-erased class Bar
+class Bar extends compiletime.Erased
 
 @experimental
 erased val foo2 = 2
diff --git a/tests/pos/i13392.scala b/tests/pos/i13392.scala
@@ -4,7 +4,7 @@ import annotation.{implicitNotFound, experimental}
 
 @experimental
 @implicitNotFound("The capability to throw exception ${E} is missing.\nThe capability can be provided by one of the following:\n - A using clause `(using CanThrow[${E}])`\n - A `throws` clause in a result type such as `X throws ${E}`\n - an enclosing `try` that catches ${E}")
-erased class CanThrow[-E <: Exception]
+class CanThrow[-E <: Exception] extends compiletime.Erased
 
 @experimental
 object unsafeExceptions:
diff --git a/tests/pos/i20206.scala b/tests/pos/i20206.scala
@@ -2,7 +2,7 @@
 
 import language.experimental.erasedDefinitions
 
-erased trait A
+trait A extends compiletime.Erased
 trait B
 
 def foo1: A ?=> B ?=> Nothing = ???
diff --git a/tests/pos/poly-erased-functions.scala b/tests/pos/poly-erased-functions.scala
@@ -7,7 +7,7 @@ object Test:
   val t1 = [X] => (erased x: X, y: Int) => y
   val t2 = [X] => (x: X, erased y: Int) => x
 
-  erased class A
+  class A extends compiletime.Erased
 
   type T3 = [X] => (x: A, y: X) => X
 
diff --git a/tests/pos/tailrec.scala b/tests/pos/tailrec.scala
@@ -2,7 +2,7 @@
 
 import scala.annotation.tailrec
 
-erased class Foo1
+class Foo1 extends compiletime.Erased
 class Foo2
 
 @tailrec
diff --git a/tests/run-macros/i12021/Test_2.scala b/tests/run-macros/i12021/Test_2.scala
diff --git a/tests/run/i13691.scala b/tests/run/i13691.scala
diff --git a/tests/run/i23305.scala b/tests/run/i23305.scala
diff --git a/tests/run/quotes-reflection/Test_2.scala b/tests/run/quotes-reflection/Test_2.scala
diff --git a/tests/run/safeThrowsStrawman.scala b/tests/run/safeThrowsStrawman.scala
diff --git a/tests/run/safeThrowsStrawman2.scala b/tests/run/safeThrowsStrawman2.scala
