Implement phantom types part 1

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -670,16 +670,6 @@ object desugar {
       tree
   }
 
-  /** EmptyTree in lower bound ==> Nothing
-   *  EmptyTree in upper bounds ==> Any
-   */
-  def typeBoundsTree(tree: TypeBoundsTree)(implicit ctx: Context): TypeBoundsTree = {
-    val TypeBoundsTree(lo, hi) = tree
-    val lo1 = if (lo.isEmpty) untpd.TypeTree(defn.NothingType) else lo
-    val hi1 = if (hi.isEmpty) untpd.TypeTree(defn.AnyType) else hi
-    cpy.TypeBoundsTree(tree)(lo1, hi1)
-  }
-
   /** Make closure corresponding to function.
    *      params => body
    *  ==>

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

@@ -820,7 +820,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)
 
   /** Classes that are known not to have an initializer irrespective of
    *  whether NoInits is set. Note: FunctionXXLClass is in this set
@@ -832,7 +832,7 @@ class Definitions {
    *  trait gets screwed up. Therefore, it is mandatory that FunctionXXL
    *  is treated as a NoInit trait.
    */
-  lazy val NoInitClasses = PhantomClasses + FunctionXXLClass
+  lazy val NoInitClasses = NotRuntimeClasses + FunctionXXLClass
 
   def isPolymorphicAfterErasure(sym: Symbol) =
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf)
@@ -936,7 +936,8 @@ class Definitions {
     NullClass,
     NothingClass,
     SingletonClass,
-    EqualsPatternClass)
+    EqualsPatternClass,
+    PhantomClass)
 
   lazy val syntheticCoreClasses = syntheticScalaClasses ++ List(
     EmptyPackageVal,
@@ -963,4 +964,23 @@ class Definitions {
       _isInitialized = true
     }
   }
+
+  // ----- Phantoms ---------------------------------------------------------
+
+  lazy val PhantomClass: ClassSymbol = {
+    val cls = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.Phantom, NoInitsTrait, List(AnyType)))
+
+    val any = enterCompleteClassSymbol(cls, tpnme.Any, Protected | Final | NoInitsTrait, Nil)
+    val nothing = enterCompleteClassSymbol(cls, tpnme.Nothing, Protected | Final | NoInitsTrait, List(any.typeRef))
+    enterMethod(cls, nme.assume_, MethodType(Nil, nothing.typeRef), Protected | Final | Method)
+
+    cls
+  }
+  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 isPhantomTerminalClass(sym: Symbol) = (sym eq Phantom_AnyClass) || (sym eq Phantom_NothingClass)
+
 }

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

@@ -0,0 +1,28 @@
+package dotty.tools.dotc.core
+
+import dotty.tools.dotc.ast.tpd._
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Symbols.defn
+import dotty.tools.dotc.core.Types.Type
+
+/** Phantom erasure erases (minimal erasure):
+ *
+ *  - Parameters/arguments are erased to BoxedUnit. The next step will remove the parameters
+ *    from the method definitions and calls (implemented in branch implement-phantom-types-part-2).
+ *  - Definitions of `def`, `val`, `lazy val` and `var` returning a phantom type to return a BoxedUnit. The next step
+ *    is to erase the fields for phantom types (implemented in branch implement-phantom-types-part-3)
+ *  - Calls to Phantom.assume become calls to BoxedUnit. Intended to be optimized away by local optimizations.
+ *
+ *  BoxedUnit is used as it fits perfectly and homogeneously in all locations where phantoms can be found.
+ *  Additionally some of the optimizations that can be performed on phantom types can also be directly implemented
+ *  on all boxed units.
+ */
+object PhantomErasure {
+
+  /** Returns the default erased type of a phantom type */
+  def erasedPhantomType(implicit ctx: Context): Type = defn.BoxedUnitType
+
+  /** Returns the default erased tree for a call to Phantom.assume */
+  def erasedAssume(implicit ctx: Context): Tree = ref(defn.BoxedUnit_UNIT)
+
+}

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

@@ -237,6 +237,8 @@ object StdNames {
     final val SourceFileATTR: N             = "SourceFile"
     final val SyntheticATTR: N              = "Synthetic"
 
+    final val Phantom: N = "Phantom"
+
 // ----- Term names -----------------------------------------
 
     // Compiler-internal

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

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

@@ -47,6 +47,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
@@ -63,6 +64,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (myNullClass == null) myNullClass = defn.NullClass
     myNullClass
   }
+  def PhantomNothingClass = {
+    if (myPhantomNothingClass == null) myPhantomNothingClass = defn.Phantom_NothingClass
+    myPhantomNothingClass
+  }
   def ObjectClass = {
     if (myObjectClass == null) myObjectClass = defn.ObjectClass
     myObjectClass
@@ -550,8 +555,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
             case _ => false
           }
-          (tp1.symbol eq NothingClass) && tp2.isValueTypeOrLambda ||
-          (tp1.symbol eq NullClass) && isNullable(tp2)
+          val sym1 = tp1.symbol
+          (sym1 eq NothingClass) && tp2.isValueTypeOrLambda && !tp2.isPhantom ||
+          (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/TypeErasure.scala

@@ -364,6 +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.isPhantomTerminalClass(tp.symbol)) PhantomErasure.erasedPhantomType
       else eraseNormalClassRef(tp)
     case tp: RefinedType =>
       val parent = tp.parent
@@ -403,7 +404,8 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
             case tr :: trs1 =>
               assert(!tr.classSymbol.is(Trait), cls)
               val tr1 = if (cls is Trait) defn.ObjectType else tr
-              tr1 :: trs1.filterNot(_ isRef defn.ObjectClass)
+              // We remove the Phantom trait to erase the definitions of Phantom.{assume, Any, Nothing}
+              tr1 :: trs1.filterNot(x => x.isRef(defn.ObjectClass) || x.isRef(defn.PhantomClass))
             case nil => nil
           }
         val erasedDecls = decls.filteredScope(sym => !sym.isType || sym.isClass)
@@ -506,6 +508,8 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         }
         if (defn.isSyntheticFunctionClass(sym))
           sigName(defn.erasedFunctionType(sym))
+        else if (defn.isPhantomTerminalClass(tp.symbol))
+          sigName(PhantomErasure.erasedPhantomType)
         else
           normalizeClass(sym.asClass).fullName.asTypeName
       case defn.ArrayOf(elem) =>

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

@@ -172,7 +172,44 @@ object Types {
         case _ =>
           false
       }
-      cls == defn.AnyClass || loop(this)
+      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
+     */
+    final def topType(implicit ctx: Context): Type = {
+      val lattice = phantomLatticeType
+      if (lattice.exists) lattice.select(tpnme.Any)
+      else 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 = {
+      val lattice = phantomLatticeType
+      if (lattice.exists) lattice.select(tpnme.Nothing)
+      else defn.NothingType
+    }
+
+    /** Returns the type of the phantom 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
+      */
+    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.superType ne this => tp.underlying.phantomLatticeType
+      case tp: AndOrType => tp.tp1.phantomLatticeType
+      case _ => NoType
     }
 
     /** Is this type guaranteed not to have `null` as a value?

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -57,6 +57,15 @@ public enum ErrorMessageID {
     CyclicReferenceInvolvingImplicitID,
     SuperQualMustBeParentID,
     AmbiguousImportID,
+    ErasedPhantomsSignatureCollisionID,
+    PhantomInheritanceID,
+    PhantomMixedBoundsID,
+    PhantomCrossedMixedBoundsID,
+    MatchPhantomID,
+    MatchOnPhantomID,
+    IfElsePhantomID,
+    PhantomIsInObjectID,
+    PhantomObjectIsInPackageOrObjectID,
     ;
 
     public int errorNumber() {

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -135,7 +135,7 @@ object messages {
   }
 
   case class EmptyCatchBlock(tryBody: untpd.Tree)(implicit ctx: Context)
- extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchBlockID) {
+  extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchBlockID) {
     val kind = "Syntax"
     val msg =
       hl"""|The ${"catch"} block does not contain a valid expression, try
@@ -1252,5 +1252,85 @@ object messages {
            |  ${"import"} scala.{ $name => ${name.show + "Tick"} }
            |"""
   }
+
+  case class ErasedPhantomsSignatureCollision(decls: Iterable[Symbol], erased: (Name, Type))(implicit ctx: Context)
+  extends Message(ErasedPhantomsSignatureCollisionID) {
+    val kind = "Phantom restriction"
+    val msg = em"After phantom erasure methods $methodsString will have the same signature: ${erased._1}${erased._2}"
 
+    private def methodsString = decls.map(decl => em"${decl.name}${decl.info}").mkString(", ")
+
+    val explanation =
+      hl"""|Phantom erasure removes all phantom parameters/arguments from methods and functions.
+           |""".stripMargin
+  }
+
+  case class PhantomInheritance(cdef: tpd.TypeDef)(implicit ctx: Context)
+  extends Message(PhantomInheritanceID) {
+    val kind = "Phantom restriction"
+    val msg = perfix + " cannot extend both Any and PhantomAny."
+
+    def perfix =
+      if (cdef.symbol.flags.is(Flags.Trait)) "A trait"
+      else if (cdef.symbol.flags.is(Flags.Abstract)) "An abstract class"
+      else "A class"
+
+    val explanation =
+      hl"""|""".stripMargin
+  }
+
+  case class PhantomMixedBounds(op: untpd.Ident)(implicit ctx: Context)
+  extends Message(PhantomMixedBoundsID) {
+    val kind = "Phantom restriction"
+    val msg = hl"Can not mix types of ${"Any"} and ${"Phantom.Any"} with ${op.show}."
+
+    val explanation =
+      hl"""|""".stripMargin
+  }
+
+  case class PhantomCrossedMixedBounds(lo: untpd.Tree, hi: untpd.Tree)(implicit ctx: Context)
+  extends Message(PhantomCrossedMixedBoundsID) {
+    val kind = "Phantom restriction"
+    val msg = hl"Type can not be bounded at the same time by types in the ${"Any"} and ${"Phantom.Any"} latices."
+
+    val explanation =
+      hl"""|""".stripMargin
+  }
+
+  case class MatchPhantom(tpdCase: tpd.CaseDef, expected: Type)(implicit ctx: Context) extends Message(MatchPhantomID) {
+    val kind = "Phantom restriction"
+    val msg = s"Pattern expected case to return a ${expected.show} but was ${tpdCase.tpe.show}"
+
+    val explanation =
+      hl"""|""".stripMargin
+  }
+
+
+  case class MatchOnPhantom()(implicit ctx: Context) extends Message(MatchOnPhantomID) {
+    val kind = "Phantom restriction"
+    val msg = "Cannot pattern match on phantoms"
+
+    val explanation =
+      hl"""|""".stripMargin
+  }
+
+  case class IfElsePhantom(thenp: tpd.Tree, elsep: tpd.Tree)(implicit ctx: Context) extends Message(IfElsePhantomID) {
+    val kind = "Phantom restriction"
+    val msg =
+      s"""if/else cannot have branches with types in different lattices:
+         |  ${thenp.tpe.show} of lattice ${thenp.tpe.topType.show}
+         |  ${elsep.tpe.show} of lattice ${elsep.tpe.topType.show}
+       """.stripMargin
+
+    val explanation =
+      hl"""|""".stripMargin
+  }
+
+  case class PhantomIsInObject()(implicit ctx: Context) extends Message(PhantomIsInObjectID) {
+    val kind = "Phantom restriction"
+    val msg = s"Only ${"object"} can extend ${"scala.Phantom"}"
+
+    val explanation =
+      hl"""|""".stripMargin
+  }  
 }

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

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

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

@@ -23,7 +23,7 @@ import core.Decorators._
 import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import ast.Trees._
 import scala.collection.mutable.ListBuffer
-import dotty.tools.dotc.core.{Constants, Flags}
+import core.{Constants, Flags, Mode, PhantomErasure}
 import ValueClasses._
 import TypeUtils._
 import ExplicitOuter._
@@ -454,6 +454,8 @@ object Erasure extends TypeTestsCasts{
       val Apply(fun, args) = tree
       if (fun.symbol == defn.cbnArg)
         typedUnadapted(args.head, pt)
+      else if (fun.symbol eq defn.Phantom_assume)
+        PhantomErasure.erasedAssume
       else typedExpr(fun, FunProto(args, pt, this)) match {
         case fun1: Apply => // arguments passed in prototype were already passed
           fun1

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

@@ -174,7 +174,7 @@ 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.NoInitClasses.contains(baseCls)) Nil
         else {

compiler/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
   }