Replace phantomTop by general top type.

Author: nicolasstucki

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

@@ -990,16 +990,6 @@ class Definitions {
   def isPhantomAssume(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.name == nme.assume_ && (sym.owner eq PhantomClass)
 
-  def topOf(tp: Type)(implicit ctx: Context): Type = tp.phantomTopClass match {
-    case top: ClassInfo => top.prefix.select(tpnme.Any)
-    case _ => defn.AnyType
-  }
-
-  def bottomOf(tp: Type)(implicit ctx: Context): Type = tp.phantomTopClass match {
-    case top: ClassInfo => top.prefix.select(tpnme.Nothing)
-    case _ => defn.NothingType
-  }
-
   lazy val ErasedPhantomClass = ctx.requiredClass("dotty.runtime.ErasedPhantom")
   def ErasedPhantomType = ErasedPhantomClass.typeRef
 

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

@@ -559,7 +559,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           }
           if (tp1.symbol eq NothingClass) tp2.isValueTypeOrLambda && !isPhantom(tp2)
           else if (tp1.symbol eq NullClass) isNullable(tp2) && !isPhantom(tp2)
-          else if (defn.isPhantomNothingClass(tp1.symbol)) tp2.isValueTypeOrLambda && (tp1.phantomTopClass == tp2.phantomTopClass)
+          else if (defn.isPhantomNothingClass(tp1.symbol)) tp2.isValueTypeOrLambda && (tp1.topType == tp2.topType)
           else false
       }
     case tp1: SingletonType =>

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

@@ -175,15 +175,31 @@ object Types {
       loop(this)
     }
 
-    final def isPhantom(implicit ctx: Context): Boolean = phantomTopClass.exists
+    /** Is phantom if upper bounded by XYZ.Any where XYZ extends scala.Phantom */
+    final def isPhantom(implicit ctx: Context): Boolean = isPhantomClass(topType.classSymbol)
 
-    final def phantomTopClass(implicit ctx: Context): Type = this match {
-      case tp: ClassInfo if isPhantomClass(tp.classSymbol) => tp
-      case tp: TypeProxy => tp.superType.phantomTopClass
-      case tp: AndOrType => tp.tp1.phantomTopClass
-      case _ => NoType
+    /** 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
+     */
+    final def topType(implicit ctx: Context): TypeRef = this match {
+      case tp: ClassInfo if isPhantomClass(tp.classSymbol) => tp.prefix.select(tpnme.Any).asInstanceOf[TypeRef]
+      case tp: TypeProxy => tp.superType.topType
+      case tp: AndOrType => tp.tp1.topType
+      case _ => defn.AnyType
+    }
+
+    /** Returns the bottom type of the lattice
+     *   - XYZ.Nothing if XYZ extends scala.Phantom and this type is upper bounded XYZ.Any
+     *   - scala.Nothing otherwise
+     */
+    final def bottomType(implicit ctx: Context): Type = topType match {
+      case top: TypeRef if top.prefix.termSymbol ne defn.ScalaPackageVal =>
+        top.prefix.select(tpnme.Nothing)
+      case _ => defn.NothingType
     }
 
+    /** If the symbol is of the class scala.Phantom.Any or scala.Phantom.Nothing */
     private def isPhantomClass(sym: Symbol)(implicit ctx: Context): Boolean =
       sym.isClass && (sym.owner eq defn.PhantomClass)
 
@@ -3287,8 +3303,8 @@ object Types {
   /** Type bounds >: lo <: hi */
   abstract case class TypeBounds(lo: Type, hi: Type) extends CachedProxyType with TypeType {
 
-    assert(lo.isInstanceOf[TermType])
-    assert(hi.isInstanceOf[TermType])
+    assert(lo.isInstanceOf[TermType], lo)
+    assert(hi.isInstanceOf[TermType], hi)
 
     def variance: Int = 0
 

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

@@ -1136,8 +1136,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(defn.bottomOf(hi1.typeOpt)))
-    val hi2 = if (!hi1.isEmpty) hi1 else typed(untpd.TypeTree(defn.topOf(lo1.typeOpt)))
+    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 tree1 = assignType(cpy.TypeBoundsTree(tree)(lo2, hi2), lo2, hi2)
     if (ctx.mode.is(Mode.Pattern)) {
@@ -1685,7 +1685,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         case untpd.InfixOp(left, op, right) =>
           checkedTops2(left, right, PhantomCrossedMixedBounds(left, right), tree.pos)
         case EmptyTree => Set.empty
-        case _ => Set(defn.topOf(tree.typeOpt))
+        case _ => Set(tree.typeOpt.topType)
       }
     }
     checkedTops(tree)