Remove ErasedPhantom class and use Unit.

Author: nicolasstucki

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

@@ -980,7 +980,7 @@ class Definitions {
   lazy val PhantomNothingClass = PhantomClass.unforcedDecls.find(_.name eq tpnme.Nothing).asClass
   lazy val PhantomAssume = PhantomClass.unforcedDecls.find(_.name eq nme.assume_)
 
-  lazy val ErasedPhantomClass = ctx.requiredClass("dotty.runtime.ErasedPhantom")
-  def ErasedPhantomType(implicit ctx: Context) = ErasedPhantomClass.typeRef
+  /** If the symbol is of the class scala.Phantom.Any or scala.Phantom.Nothing */
+  def isPhantomClass(sym: Symbol) = (sym eq PhantomAnyClass) || (sym eq PhantomNothingClass)
 
 }

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

@@ -634,10 +634,8 @@ object SymDenotations {
     }
 
     /** Is this symbol a class references to which that are supertypes of null? */
-    final def isNullableClass(implicit ctx: Context): Boolean = {
-      isClass && !isValueClass && !(this is ModuleClass) &&
-      symbol != defn.NothingClass && symbol != defn.PhantomAnyClass && symbol != defn.PhantomNothingClass
-    }
+    final def isNullableClass(implicit ctx: Context): Boolean =
+      isClass && !isValueClass && !(this is ModuleClass) && symbol != defn.NothingClass && !defn.isPhantomClass(symbol)
 
     /** Is this definition accessible as a member of tree with type `pre`?
      *  @param pre          The type of the tree from which the selection is made

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

@@ -364,7 +364,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       else if (semiEraseVCs && isDerivedValueClass(sym)) eraseDerivedValueClassRef(tp)
       else if (sym == defn.ArrayClass) apply(tp.appliedTo(TypeBounds.empty)) // i966 shows that we can hit a raw Array type.
       else if (defn.isSyntheticFunctionClass(sym)) defn.erasedFunctionType(sym)
-      else if ((tp.symbol eq defn.PhantomAnyClass) || (tp.symbol eq defn.PhantomNothingClass)) defn.ErasedPhantomType
+      else if (defn.isPhantomClass(tp.symbol)) defn.BoxedUnitType
       else eraseNormalClassRef(tp)
     case tp: RefinedType =>
       val parent = tp.parent
@@ -507,8 +507,8 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         }
         if (defn.isSyntheticFunctionClass(sym))
           sigName(defn.erasedFunctionType(sym))
-        else if ((tp.symbol eq defn.PhantomAnyClass) || (tp.symbol eq defn.PhantomNothingClass))
-          sigName(defn.ErasedPhantomType)
+        else if (defn.isPhantomClass(tp.symbol))
+          sigName(defn.BoxedUnitType)
         else
           normalizeClass(sym.asClass).fullName.asTypeName
       case defn.ArrayOf(elem) =>

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

@@ -200,16 +200,12 @@ object Types {
       *   - NoType otherwise
       */
     final def phantomLatticeType(implicit ctx: Context): Type = widen match {
-      case tp: ClassInfo if isPhantomClass(tp.classSymbol) => tp.prefix
+      case tp: ClassInfo if defn.isPhantomClass(tp.classSymbol) => tp.prefix
       case tp: TypeProxy if tp.superType ne this => tp.superType.phantomLatticeType
       case tp: AndOrType => tp.tp1.phantomLatticeType
       case _ => NoType
     }
 
-    /** If the symbol is of the class scala.Phantom.Any or scala.Phantom.Nothing */
-    private def isPhantomClass(sym: Symbol)(implicit ctx: Context): Boolean =
-      (sym eq defn.PhantomAnyClass) || (sym eq defn.PhantomNothingClass)
-
     /** Is this type guaranteed not to have `null` as a value?
      *  For the moment this is only true for modules, but it could
      *  be refined later.

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

@@ -454,14 +454,9 @@ object Erasure extends TypeTestsCasts{
       val Apply(fun, args) = tree
       if (fun.symbol == defn.cbnArg)
         typedUnadapted(args.head, pt)
-      else if (fun.symbol eq defn.PhantomAssume) {
-        /* All phantom types are erased to `ErasedPhantom` (an un-instantiable final abstract class),
-         * hence the only valid term for a `ErasedPhantom` is `null`.
-         * As `Phantom.assume` is the only way to instantiate phantoms, all runtime values of
-         * phantom type become `null` (no instantiation overhead).
-         */
-        Literal(Constant(null)).withType(defn.ErasedPhantomType)
-      } else typedExpr(fun, FunProto(args, pt, this)) match {
+      else if (fun.symbol eq defn.PhantomAssume)
+        ref(defn.BoxedUnit_UNIT)
+      else typedExpr(fun, FunProto(args, pt, this)) match {
         case fun1: Apply => // arguments passed in prototype were already passed
           fun1
         case fun1 =>

library/src/dotty/runtime/ErasedPhantom.scala

@@ -7,7 +7,6 @@ trait Phantom {
 
   protected final abstract class Nothing extends Any
 
-  protected final def assume: this.Nothing =
-    null.asInstanceOf[this.Nothing] // This implementation matches the erased implementation
+  protected final def assume: this.Nothing
 }
 */