Implement erasable phantom types.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -11,6 +11,7 @@ import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
 import reporting.{Reporter, ConsoleReporter}
 import Phases.Phase
 import transform._
+import transform.phantom._
 import util.FreshNameCreator
 import transform.TreeTransforms.{TreeTransform, TreeTransformer}
 import core.DenotTransformers.DenotTransformer
@@ -74,6 +75,7 @@ class Compiler {
            new ResolveSuper,        // Implement super accessors and add forwarders to trait methods
            new PrimitiveForwarders, // Add forwarders to trait methods that have a mismatch between generic and primitives
            new ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
+      List(new PhantomTypeErasure), // Erases phantom types to ErasedPhantom
       List(new Erasure),            // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
       List(new ElimErasedValueType, // Expand erased value types to their underlying implmementation types
            new VCElideAllocations,  // Peep-hole optimization to eliminate unnecessary value class allocations

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

@@ -626,16 +626,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

@@ -149,17 +149,18 @@ class Definitions {
   }
 
   private def enterPolyMethod(cls: ClassSymbol, name: TermName, typeParamCount: Int,
-                    resultTypeFn: PolyType => Type, flags: FlagSet = EmptyFlags) = {
+                    resultTypeFn: PolyType => Type, flags: FlagSet = EmptyFlags,
+                    bounds: TypeName => TypeBounds = _ => TypeBounds.empty) = {
     val tparamNames = tpnme.syntheticTypeParamNames(typeParamCount)
-    val tparamBounds = tparamNames map (_ => TypeBounds.empty)
+    val tparamBounds = tparamNames map bounds
     val ptype = PolyType(tparamNames, tparamNames.map(alwaysZero))(_ => tparamBounds, resultTypeFn)
     enterMethod(cls, name, ptype, flags)
   }
 
-  private def enterT1ParameterlessMethod(cls: ClassSymbol, name: TermName, resultTypeFn: PolyType => Type, flags: FlagSet) =
+  private def enterT1ParameterlessMethod(cls: ClassSymbol, name: TermName, resultTypeFn: PolyType => Type, flags: FlagSet, bounds: TypeName => TypeBounds = _ => TypeBounds.empty) =
     enterPolyMethod(cls, name, 1, resultTypeFn, flags)
 
-  private def enterT1EmptyParamsMethod(cls: ClassSymbol, name: TermName, resultTypeFn: PolyType => Type, flags: FlagSet) =
+  private def enterT1EmptyParamsMethod(cls: ClassSymbol, name: TermName, resultTypeFn: PolyType => Type, flags: FlagSet, bounds: TypeName => TypeBounds = _ => TypeBounds.empty) =
     enterPolyMethod(cls, name, 1, pt => MethodType(Nil, resultTypeFn(pt)), flags)
 
   private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[TypeRef] = {
@@ -938,16 +939,17 @@ class Definitions {
     val newDecls = new MutableScope(oldDecls) {
       override def lookupEntry(name: Name)(implicit ctx: Context): ScopeEntry = {
         val res = super.lookupEntry(name)
-        if (res == null && name.isTypeName && name.isSyntheticFunction)
+        if (res ne null) res
+        else if (name.isTypeName && name.isSyntheticFunction)
           newScopeEntry(newFunctionNTrait(name.asTypeName))
-        else res
+        else null
       }
     }
     ScalaPackageClass.info = oldInfo.derivedClassInfo(decls = newDecls)
   }
 
   /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
-  lazy val syntheticScalaClasses = List(
+  private lazy val syntheticScalaClasses = List(
     AnyClass,
     AnyRefAlias,
     RepeatedParamClass,
@@ -956,14 +958,15 @@ class Definitions {
     NullClass,
     NothingClass,
     SingletonClass,
-    EqualsPatternClass)
+    EqualsPatternClass,
+    PhantomClass)
 
   lazy val syntheticCoreClasses = syntheticScalaClasses ++ List(
     EmptyPackageVal,
     OpsPackageClass)
 
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
-  lazy val syntheticCoreMethods = AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
+  private lazy val syntheticCoreMethods = AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
 
   lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
 
@@ -985,4 +988,44 @@ class Definitions {
       _isInitialized = true
     }
   }
+
+  // ----- Phantoms ---------------------------------------------------------
+
+  lazy val PhantomClass: ClassSymbol = {
+    val cls = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.Phantom, Abstract, List(AnyType)))
+
+    val any = enterCompleteClassSymbol(cls, tpnme.Any, Protected | Final | NoInitsTrait, Nil)
+    val nothing = enterCompleteClassSymbol(cls, tpnme.Nothing, Protected | Final | NoInitsTrait, List(any.typeRef))
+
+    val tparamNames = tpnme.syntheticTypeParamNames(1)
+    val ptype = PolyType(tparamNames, List(0))(_ => TypeBounds(nothing.typeRef, any.typeRef) :: Nil, PolyParam(_, 0))
+    newSymbol(cls, nme.assume_, Protected | Final | Method, ptype).entered
+
+    cls
+  }
+
+  def isPhantomAnyClass(sym: Symbol)(implicit ctx: Context): Boolean =
+    sym.exists && (sym.owner eq PhantomClass) && sym.name == tpnme.Any
+
+  def isPhantomNothingClass(sym: Symbol)(implicit ctx: Context): Boolean =
+    sym.exists && (sym.owner eq PhantomClass) && sym.name == tpnme.Nothing
+
+  def isPhantomAssume(sym: Symbol)(implicit ctx: Context): Boolean =
+    sym.exists && (sym.owner eq PhantomClass) && sym.name == nme.assume_
+
+  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
+
+  lazy val ErasedPhantomLatticeClass = ctx.requiredClass("dotty.runtime.ErasedPhantomLattice")
+  def ErasedPhantomLatticeType = ErasedPhantomLatticeClass.typeRef
 }

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

@@ -230,6 +230,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/TypeComparer.scala

@@ -12,6 +12,7 @@ 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.
  */
@@ -550,8 +551,16 @@ 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)
+          def isPhantom(tp: Type): Boolean = tp.widenDealias match {
+            case tp: TypeRef => defn.isPhantomAnyClass(tp.symbol)
+            case tp: RefinedOrRecType => isPhantom(tp.parent)
+            case tp: AndOrType => isPhantom(tp.tp1)
+            case _ => false
+          }
+          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 false
       }
     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/TypeOps.scala

@@ -15,6 +15,8 @@ import util.{SimpleMap, Property}
 import collection.mutable
 import ast.tpd._
 
+import scala.annotation.tailrec
+
 trait TypeOps { this: Context => // TODO: Make standalone object.
 
   /** The type `tp` as seen from prefix `pre` and owner `cls`. See the spec
@@ -199,7 +201,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     }
 
     /** The minimal set of classes in `cs` which derive all other classes in `cs` */
-    def dominators(cs: List[ClassSymbol], accu: List[ClassSymbol]): List[ClassSymbol] = (cs: @unchecked) match {
+    @tailrec def dominators(cs: List[ClassSymbol], accu: List[ClassSymbol]): List[ClassSymbol] = cs match {
       case c :: rest =>
         val accu1 = if (accu exists (_ derivesFrom c)) accu else c :: accu
         if (cs == c.baseClasses) accu1 else dominators(rest, accu1)
@@ -255,7 +257,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
                   else tp.baseTypeWithArgs(cls)
                 base.mapReduceOr(identity)(mergeRefined)
               }
-              doms.map(baseTp).reduceLeft(AndType.apply)
+              if (doms.isEmpty) new ErrorType("no parents in common") // This can happen in the union of Any with PhantomAny
+              else doms.map(baseTp).reduceLeft(AndType.apply)
           }
       }
     }

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

@@ -169,9 +169,21 @@ object Types {
         case _ =>
           false
       }
-      cls == defn.AnyClass || loop(this)
+      loop(this)
+    }
+
+    final def isPhantom(implicit ctx: Context): Boolean = phantomTopClass.exists
+
+    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
     }
 
+    private def isPhantomClass(sym: Symbol)(implicit ctx: Context): Boolean =
+      sym.isClass && (sym.owner eq defn.PhantomClass) && (sym.name == tpnme.Any || sym.name == tpnme.Nothing)
+
     /** Is this type guaranteed not to have `null` as a value?
      *  For the moment this is only true for modules, but it could
      *  be refined later.

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

@@ -55,6 +55,14 @@ public enum ErrorMessageID {
     RecursiveValueNeedsResultTypeID,
     CyclicReferenceInvolvingID,
     CyclicReferenceInvolvingImplicitID,
+    ErasedPhantomsSignatureCollisionID,
+    PhantomInheritanceID,
+    PhantomMixedBoundsID,
+    PhantomCrossedMixedBoundsID,
+    MatchPhantomID,
+    MatchOnPhantomID,
+    IfElsePhantomID,
+    PhantomIsInObjectID,
     ;
 
     public int errorNumber() {

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

@@ -10,6 +10,7 @@ import Symbols._
 import Names._
 import NameOps._
 import Types._
+import Flags._
 import util.SourcePosition
 import config.Settings.Setting
 import interfaces.Diagnostic.{ERROR, INFO, WARNING}
@@ -133,7 +134,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
@@ -1192,4 +1193,81 @@ object messages {
            |""".stripMargin
   }
 
+
+  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()(implicit ctx: Context) extends Message(MatchPhantomID) {
+    val kind = "Phantom restriction"
+    val msg = "Pattern matches cannot return phantom and non phantoms"
+
+    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()(implicit ctx: Context) extends Message(IfElsePhantomID) {
+    val kind = "Phantom restriction"
+    val msg = "Cannot yield a phantom type in one of the if branches and not in the other one."
+
+    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/phantom/PhantomTypeErasure.scala

@@ -0,0 +1,55 @@
+package dotty.tools.dotc.transform.phantom
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.DenotTransformers._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+
+class PhantomTypeErasure extends MiniPhaseTransform with InfoTransformer {
+
+  import tpd._
+
+  override def phaseName: String = "phantomTypeErasure"
+
+  /** Check what the phase achieves, to be called at any point after it is finished. */
+  override def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = {
+    assert(!tree.tpe.isPhantom, tree.tpe + " should be erased in " + tree)
+  }
+
+  /* Tree transform */
+
+  override def transformTypeTree(tree: TypeTree)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val newTpe = erasePhantomAnyType(tree.tpe)
+    if (newTpe =:= tree.tpe) tree else TypeTree(newTpe)
+  }
+
+  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree =
+    if (defn.isPhantomAssume(tree.fun.symbol)) Literal(Constant(null)).withType(defn.ErasedPhantomType) else tree
+
+  /* Symbol transform */
+
+  def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = erasePhantomAnyType(tp)
+
+  /* private methods */
+
+  private def erasePhantomAnyType(tp: Type)(implicit ctx: Context): Type = {
+    val erasePhantomAnyTypeMap = new DeepTypeMap {
+      override def apply(tp: Type): Type = tp match {
+        case tp: TypeRef if defn.isPhantomAnyClass(tp.symbol) || defn.isPhantomNothingClass(tp.symbol) =>
+          defn.ErasedPhantomType
+        case tp: TypeRef if tp.typeSymbol eq defn.PhantomClass =>
+          defn.ErasedPhantomLatticeType
+        case tp: MethodType if tp.resultType.isPhantom =>
+          // Erase return type to Object to match FunctionN erased return type
+          val methodType = if (tp.isImplicit) ImplicitMethodType else MethodType
+          methodType(tp.paramNames, tp.paramTypes, defn.ObjectType)
+        case _ => mapOver(tp)
+      }
+    }
+    erasePhantomAnyTypeMap(tp)
+  }
+
+}