Rename Phantoms in defn and add Type.isPhantom.

Author: nicolasstucki

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

@@ -976,11 +976,11 @@ class Definitions {
 
     cls
   }
-  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 Phantom_AnyClass = PhantomClass.unforcedDecls.find(_.name eq tpnme.Any).asClass
+  lazy val Phantom_NothingClass = PhantomClass.unforcedDecls.find(_.name eq tpnme.Nothing).asClass
+  lazy val Phantom_assume = PhantomClass.unforcedDecls.find(_.name eq nme.assume_)
 
   /** If the symbol is of the class scala.Phantom.Any or scala.Phantom.Nothing */
-  def isPhantomClass(sym: Symbol) = (sym eq PhantomAnyClass) || (sym eq PhantomNothingClass)
+  def isPhantomTerminalClass(sym: Symbol) = (sym eq Phantom_AnyClass) || (sym eq Phantom_NothingClass)
 
 }

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

@@ -635,7 +635,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 && !defn.isPhantomClass(symbol)
+      isClass && !isValueClass && !(this is ModuleClass) && symbol != defn.NothingClass && !defn.isPhantomTerminalClass(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/TypeComparer.scala

@@ -12,7 +12,6 @@ import config.Printers.{typr, constr, subtyping, noPrinter}
 import TypeErasure.{erasedLub, erasedGlb}
 import TypeApplications._
 import scala.util.control.NonFatal
-import scala.annotation.tailrec
 
 /** Provides methods to compare types.
  */
@@ -48,7 +47,6 @@ 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 myPhantomAnyClass: ClassSymbol = null
   private var myPhantomNothingClass: ClassSymbol = null
   private var myObjectClass: ClassSymbol = null
   private var myAnyType: TypeRef = null
@@ -66,12 +64,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (myNullClass == null) myNullClass = defn.NullClass
     myNullClass
   }
-  def PhantomAnyClass = {
-    if (myPhantomAnyClass == null) myPhantomAnyClass = defn.PhantomAnyClass
-    myPhantomAnyClass
-  }
   def PhantomNothingClass = {
-    if (myPhantomNothingClass == null) myPhantomNothingClass = defn.PhantomNothingClass
+    if (myPhantomNothingClass == null) myPhantomNothingClass = defn.Phantom_NothingClass
     myPhantomNothingClass
   }
   def ObjectClass = {
@@ -561,14 +555,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
             case _ => false
           }
-          def isPhantom(tp: Type): Boolean = {
-            // note that the only phantom classes are PhantomAnyClass and PhantomNothingClass
-            val sym = tp.typeSymbol
-            (sym eq PhantomAnyClass) || (sym eq PhantomNothingClass) ||
-            (!sym.isClass && tp.phantomLatticeType.exists)
-          }
           val sym1 = tp1.symbol
-          (sym1 eq NothingClass) && tp2.isValueTypeOrLambda && !isPhantom(tp2) ||
+          (sym1 eq NothingClass) && tp2.isValueTypeOrLambda && !tp2.isPhantom ||
           (sym1 eq NullClass) && isNullable(tp2) ||
           (sym1 eq PhantomNothingClass) && tp1.topType == tp2.topType
       }

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.isPhantomClass(tp.symbol)) defn.BoxedUnitType
+      else if (defn.isPhantomTerminalClass(tp.symbol)) defn.BoxedUnitType
       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.isPhantomClass(tp.symbol))
+        else if (defn.isPhantomTerminalClass(tp.symbol))
           sigName(defn.BoxedUnitType)
         else
           normalizeClass(sym.asClass).fullName.asTypeName

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

@@ -175,6 +175,12 @@ object Types {
       loop(this)
     }
 
+    /** Returns true if the type is a phantom type
+     *   - true if XYZ extends scala.Phantom and this type is upper bounded XYZ.Any
+     *   - false otherwise
+     */
+    final def isPhantom(implicit ctx: Context): Boolean = phantomLatticeType.exists
+
     /** Returns the top type of the lattice
      *   - XYX.Any if XYZ extends scala.Phantom and this type is upper bounded XYZ.Any
      *   - scala.Any otherwise
@@ -195,13 +201,13 @@ object Types {
       else defn.NothingType
     }
 
-    /** Returns the type of the lattice
+    /** Returns the type of the lattice (i.e. the prefix of the phantom type)
       *   - XYZ if XYZ extends scala.Phantom and this type is upper bounded XYZ.Any
       *   - NoType otherwise
       */
-    final def phantomLatticeType(implicit ctx: Context): Type = widen match {
-      case tp: ClassInfo if defn.isPhantomClass(tp.classSymbol) => tp.prefix
-      case tp: TypeProxy if tp.superType ne this => tp.superType.phantomLatticeType
+    private final def phantomLatticeType(implicit ctx: Context): Type = widen match {
+      case tp: ClassInfo if defn.isPhantomTerminalClass(tp.classSymbol) => tp.prefix
+      case tp: TypeProxy if tp.underlying ne this => tp.underlying.phantomLatticeType
       case tp: AndOrType => tp.tp1.phantomLatticeType
       case _ => NoType
     }

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.cbnArg)
         typedUnadapted(args.head, pt)
-      else if (fun.symbol eq defn.PhantomAssume)
+      else if (fun.symbol eq defn.Phantom_assume)
         ref(defn.BoxedUnit_UNIT)
       else typedExpr(fun, FunProto(args, pt, this)) match {
         case fun1: Apply => // arguments passed in prototype were already passed

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -431,7 +431,7 @@ trait TypeAssigner {
     tree.withType(body.tpe)
 
   def assignType(tree: untpd.Match, cases: List[CaseDef])(implicit ctx: Context) = {
-    if (tree.selector.typeOpt.phantomLatticeType.exists)
+    if (tree.selector.typeOpt.isPhantom)
       ctx.error("Cannot pattern match on phantoms", tree.selector.pos)
     if (cases.nonEmpty) {
       val head = cases.head

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1126,8 +1126,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val lo1 = typed(lo)
     val hi1 = typed(hi)
 
-    val lo2 = if (!lo1.isEmpty) lo1 else typed(untpd.TypeTree(hi1.typeOpt.bottomType))
-    val hi2 = if (!hi1.isEmpty) hi1 else typed(untpd.TypeTree(lo1.typeOpt.topType))
+    val lo2 = if (lo1.isEmpty) typed(untpd.TypeTree(hi1.typeOpt.bottomType)) else lo1
+    val hi2 = if (hi1.isEmpty) typed(untpd.TypeTree(lo1.typeOpt.topType)) else hi1
 
     val tree1 = assignType(cpy.TypeBoundsTree(tree)(lo2, hi2), lo2, hi2)
     if (ctx.mode.is(Mode.Pattern)) {