Rename old PhantomClasses to avoid name clashes with phantom types.

Author: nicolasstucki

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

@@ -650,7 +650,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)
 
   def isPolymorphicAfterErasure(sym: Symbol) =
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf)
@@ -723,7 +723,7 @@ class Definitions {
   def wrapArrayMethodName(elemtp: Type): TermName = {
     val cls = elemtp.classSymbol
     if (cls.isPrimitiveValueClass) nme.wrapXArray(cls.name)
-    else if (cls.derivesFrom(ObjectClass) && !cls.isPhantomClass) nme.wrapRefArray
+    else if (cls.derivesFrom(ObjectClass) && !cls.isNotRuntimeClass) nme.wrapRefArray
     else nme.genericWrapArray
   }
 

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

@@ -468,8 +468,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

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

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

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

@@ -173,9 +173,9 @@ 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.PhantomClasses.contains(baseCls)) Nil
+        if (baseCls.is(NoInitsTrait) || defn.NotRuntimeClasses.contains(baseCls)) Nil
         else {
           //println(i"synth super call ${baseCls.primaryConstructor}: ${baseCls.primaryConstructor.info}")
           transformFollowingDeep(superRef(baseCls.primaryConstructor).appliedToNone) :: Nil

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
   }