Improve names of phantom classes in defn.

Author: nicolasstucki

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

@@ -977,8 +977,8 @@ class Definitions {
 
     cls
   }
-  lazy val PhantomAny = PhantomClass.unforcedDecls.find(_.name eq tpnme.Any).asClass
-  lazy val PhantomNothing = PhantomClass.unforcedDecls.find(_.name eq tpnme.Nothing).asClass
+  lazy val PhantomAnyClass = PhantomClass.unforcedDecls.find(_.name eq tpnme.Any).asClass
+  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")

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

@@ -636,7 +636,7 @@ 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.PhantomAny && symbol != defn.PhantomNothing
+      symbol != defn.NothingClass && symbol != defn.PhantomAnyClass && symbol != defn.PhantomNothingClass
     }
 
     /** Is this definition accessible as a member of tree with type `pre`?

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

@@ -67,11 +67,11 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     myNullClass
   }
   def PhantomAnyClass = {
-    if (myPhantomAnyClass == null) myPhantomAnyClass = defn.PhantomAny
+    if (myPhantomAnyClass == null) myPhantomAnyClass = defn.PhantomAnyClass
     myPhantomAnyClass
   }
   def PhantomNothingClass = {
-    if (myPhantomNothingClass == null) myPhantomNothingClass = defn.PhantomNothing
+    if (myPhantomNothingClass == null) myPhantomNothingClass = defn.PhantomNothingClass
     myPhantomNothingClass
   }
   def ObjectClass = {

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.PhantomAny) || (tp.symbol eq defn.PhantomNothing)) defn.ErasedPhantomType
+      else if ((tp.symbol eq defn.PhantomAnyClass) || (tp.symbol eq defn.PhantomNothingClass)) defn.ErasedPhantomType
       else eraseNormalClassRef(tp)
     case tp: RefinedType =>
       val parent = tp.parent
@@ -507,7 +507,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         }
         if (defn.isSyntheticFunctionClass(sym))
           sigName(defn.erasedFunctionType(sym))
-        else if ((tp.symbol eq defn.PhantomAny) || (tp.symbol eq defn.PhantomNothing))
+        else if ((tp.symbol eq defn.PhantomAnyClass) || (tp.symbol eq defn.PhantomNothingClass))
           sigName(defn.ErasedPhantomType)
         else
           normalizeClass(sym.asClass).fullName.asTypeName

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

@@ -208,7 +208,7 @@ object Types {
 
     /** 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.PhantomAny) || (sym eq defn.PhantomNothing)
+      (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