Cache PhantomNothing, PhantomAny and PhantomAssume symbols.

Author: nicolasstucki

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

@@ -976,15 +976,9 @@ class Definitions {
 
     cls
   }
-
-  def isPhantomAnyOrNothingClass(sym: Symbol)(implicit ctx: Context): Boolean =
-    (sym.name == tpnme.Any || sym.name == tpnme.Nothing) && (sym.owner eq PhantomClass)
-
-  def isPhantomNothingClass(sym: Symbol)(implicit ctx: Context): Boolean =
-    sym.name == tpnme.Nothing && (sym.owner eq PhantomClass)
-
-  def isPhantomAssume(sym: Symbol)(implicit ctx: Context): Boolean =
-    sym.name == nme.assume_ && (sym.owner eq PhantomClass)
+  lazy val PhantomAny = PhantomClass.unforcedDecls.find(_.name eq tpnme.Any).asClass
+  lazy val PhantomNothing = 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

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

@@ -48,6 +48,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   private var myAnyClass: ClassSymbol = null
   private var myNothingClass: ClassSymbol = null
   private var myNullClass: ClassSymbol = null
+  private var myPhantomNothingClass: ClassSymbol = null
   private var myObjectClass: ClassSymbol = null
   private var myAnyType: TypeRef = null
   private var myNothingType: TypeRef = null
@@ -64,6 +65,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (myNullClass == null) myNullClass = defn.NullClass
     myNullClass
   }
+  def PhantomNothing = {
+    if (myPhantomNothingClass == null) myPhantomNothingClass = defn.PhantomNothing
+    myPhantomNothingClass
+  }
   def ObjectClass = {
     if (myObjectClass == null) myObjectClass = defn.ObjectClass
     myObjectClass
@@ -553,7 +558,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           }
           if (tp1.symbol eq NothingClass) tp2.isValueTypeOrLambda && (tp2.topType.classSymbol eq AnyClass)
           else if (tp1.symbol eq NullClass) isNullable(tp2) && (tp2.topType.classSymbol eq AnyClass)
-          else if (defn.isPhantomNothingClass(tp1.symbol)) tp2.isValueTypeOrLambda && (tp1.topType == tp2.topType)
+          else if (tp1.symbol eq PhantomNothing) tp2.isValueTypeOrLambda && (tp1.topType == tp2.topType)
           else false
       }
     case tp1: SingletonType =>

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 (defn.isPhantomAnyOrNothingClass(tp.symbol)) defn.ErasedPhantomType
+      else if ((tp.symbol eq defn.PhantomAny) || (tp.symbol eq defn.PhantomNothing)) 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 (defn.isPhantomAnyOrNothingClass(tp.symbol))
+        else if ((tp.symbol eq defn.PhantomAny) || (tp.symbol eq defn.PhantomNothing))
           sigName(defn.ErasedPhantomType)
         else
           normalizeClass(sym.asClass).fullName.asTypeName

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

@@ -454,7 +454,7 @@ object Erasure extends TypeTestsCasts{
       val Apply(fun, args) = tree
       if (fun.symbol == defn.dummyApply)
         typedUnadapted(args.head, pt)
-      else if (defn.isPhantomAssume(fun.symbol)) {
+      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