Rename old PhantomClasses to avoid name clashes with phantom types.

Author: nicolasstucki

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

@@ -819,7 +819,7 @@ class Definitions {
   lazy val UnqualifiedOwnerTypes: Set[NamedType] =
     RootImportTypes.toSet[NamedType] ++ RootImportTypes.map(_.symbol.moduleClass.typeRef)
 
-  lazy val PhantomClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass)
+  lazy val NotRuntimeClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass)
 
   /** Classes that are known not to have an initializer irrespective of
    *  whether NoInits is set. Note: FunctionXXLClass is in this set
@@ -831,7 +831,7 @@ class Definitions {
    *  trait gets screwed up. Therefore, it is mandatory that FunctionXXL
    *  is treated as a NoInit trait.
    */
-  lazy val NoInitClasses = PhantomClasses + FunctionXXLClass
+  lazy val NoInitClasses = NotRuntimeClasses + FunctionXXLClass
 
   def isPolymorphicAfterErasure(sym: Symbol) =
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf)

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

@@ -501,8 +501,8 @@ object SymDenotations {
     def isNumericValueClass(implicit ctx: Context) =
       maybeOwner == defn.ScalaPackageClass && defn.ScalaNumericValueClasses().contains(symbol)
 
-    /** Is symbol a phantom class for which no runtime representation exists? */
-    def isPhantomClass(implicit ctx: Context) = defn.PhantomClasses contains symbol
+    /** Is symbol a class for which no runtime representation exists? */
+    def isNotRuntimeClass(implicit ctx: Context) = defn.NotRuntimeClasses contains symbol
 
     /** Is this symbol a class representing a refinement? These classes
      *  are used only temporarily in Typer and Unpickler as an intermediate

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

@@ -89,7 +89,7 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
     case _ =>
       val elemType = tree.tpe.elemType
       var elemClass = elemType.classSymbol
-      if (defn.PhantomClasses contains elemClass) elemClass = defn.ObjectClass
+      if (defn.NotRuntimeClasses contains elemClass) elemClass = defn.ObjectClass
       ref(defn.DottyArraysModule)
         .select(nme.seqToArray)
         .appliedToType(elemType)

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

@@ -174,7 +174,7 @@ class Mixin extends MiniPhaseTransform with SymTransformer { thisTransform =>
 
     def superCallOpt(baseCls: Symbol): List[Tree] = superCalls.get(baseCls) match {
       case Some(call) =>
-        if (defn.PhantomClasses.contains(baseCls)) Nil else call :: Nil
+        if (defn.NotRuntimeClasses.contains(baseCls)) Nil else call :: Nil
       case None =>
         if (baseCls.is(NoInitsTrait) || defn.NoInitClasses.contains(baseCls)) Nil
         else {

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

@@ -14,7 +14,7 @@ object TreeGen {
   def wrapArrayMethodName(elemtp: Type)(implicit ctx: Context): TermName = {
     val elemCls = elemtp.classSymbol
     if (elemCls.isPrimitiveValueClass) nme.wrapXArray(elemCls.name)
-    else if (elemCls.derivesFrom(defn.ObjectClass) && !elemCls.isPhantomClass) nme.wrapRefArray
+    else if (elemCls.derivesFrom(defn.ObjectClass) && !elemCls.isNotRuntimeClass) nme.wrapRefArray
     else nme.genericWrapArray
   }