Drop erased class

Replace with test whether a type derivesFrom Erased.

Author: odersky

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")

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

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)
     }
 

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
 

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

@@ -608,10 +608,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)

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

@@ -1769,24 +1769,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 = params3.zipWithConserve(mt.paramInfos.map(_.isErasedClass)) { (arg, isErasedClass) =>
-          if isErasedClass then arg.withAddedFlags(Erased) else arg
-        }
-        return typedDependent(newParams)
-      val core =
-        if mt.hasErasedParams then TypeTree(defn.PolyFunctionClass.typeRef)
-        else
-          val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.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 = params3.zipWithConserve(mt.paramInfos): (param, info) =>
+          if info.derivesFrom(defn.ErasedClass) then param.withAddedFlags(Erased) else param
+        typedDependent(newParams)
       else
-        res
+        val core =
+          if mt.hasErasedParams then TypeTree(defn.PolyFunctionClass.typeRef)
+          else
+            val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.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 {
@@ -1801,7 +1803,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           val result = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt)
           // if there are any erased classes, we need to re-do the typecheck.
           result 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 _ => result
     }
@@ -2944,6 +2946,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) =>
@@ -3068,16 +3072,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
 

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:

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

tests/neg/erased-inheritance.scala renamed to tests/invalid/neg/erased-inheritance.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