Shortcircuit slow path typing Nothing <:< XYZ for non phantoms.

Author: nicolasstucki

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

@@ -652,8 +652,10 @@ 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
+    final def isNullableClass(implicit ctx: Context): Boolean = {
+      isClass && !isValueClass && !(this is ModuleClass) &&
+      symbol != defn.NothingClass && symbol != defn.PhantomAny && symbol != defn.PhantomNothing
+    }
 
     /** 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

@@ -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 myPhantomAnyClass: ClassSymbol = null
   private var myPhantomNothingClass: ClassSymbol = null
   private var myObjectClass: ClassSymbol = null
   private var myAnyType: TypeRef = null
@@ -65,7 +66,11 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (myNullClass == null) myNullClass = defn.NullClass
     myNullClass
   }
-  def PhantomNothing = {
+  def PhantomAnyClass = {
+    if (myPhantomAnyClass == null) myPhantomAnyClass = defn.PhantomAny
+    myPhantomAnyClass
+  }
+  def PhantomNothingClass = {
     if (myPhantomNothingClass == null) myPhantomNothingClass = defn.PhantomNothing
     myPhantomNothingClass
   }
@@ -556,10 +561,16 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
             case _ => false
           }
-          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 (tp1.symbol eq PhantomNothing) tp2.isValueTypeOrLambda && (tp1.topType == tp2.topType)
-          else 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.topType.classSymbol eq PhantomAnyClass))
+          }
+          val sym1 = tp1.symbol
+          (sym1 eq NothingClass) && tp2.isValueTypeOrLambda && !isPhantom(tp2) ||
+          (sym1 eq NullClass) && isNullable(tp2) ||
+          (sym1 eq PhantomNothingClass) && tp1.topType == tp2.topType
       }
     case tp1: SingletonType =>
       /** if `tp2 == p.type` and `p: q.type` then try `tp1 <:< q.type` as a last effort.*/

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

@@ -176,7 +176,12 @@ object Types {
     }
 
     /** 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 isPhantom(implicit ctx: Context): Boolean = {
+      // note that the only phantom classes are PhantomAnyClass and PhantomNothingClass
+      val sym = typeSymbol
+      (sym eq defn.PhantomAny) || (sym eq defn.PhantomNothing) ||
+      (!sym.isClass && (topType.classSymbol eq defn.PhantomAny))
+    }
 
     /** Returns the top type of the lattice
      *   - XYX.Any if XYZ extends scala.Phantom and this type is upper bounded XYZ.Any
@@ -201,7 +206,7 @@ object Types {
 
     /** 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)
+      (sym eq defn.PhantomAny) || (sym eq defn.PhantomNothing)
 
     /** Is this type guaranteed not to have `null` as a value?
      *  For the moment this is only true for modules, but it could