Add erasable phantom types.

Phantom type are types for which values have no runtime use. For this
purose the phase PhantomErasure will remove all terms that derive from
PantomAny.

The latice bounded by PhantomAny and PhantomNothing is completely disjoint
of the runtime types (Any/Nothing). Therefore if PhantomNothing <: P <: PhantomAny
then Nothing <: P <: Any is false. Conversly if Nothing <: T <: Any then
PhantomNothing <: T <: PhantomAny is false.

PhantomErasure will remove:
* Parameters that are subtype of PhantomAny.
* Arguments that are subtype of PhantomAny.
* Calls to functions that return a value of subtype of PhantomAny.
* Value or method definitions that return a value of a subtype of PhantomAny.

Additional restrictions:
* In a curried function groups of parameters are either all Any or all PhantomAny.
* Expressions of phantom types cant be used in statement position.
* `var` and `lazy val` can not be phantom types.
* Mixing phantom types with types of `Any` using type bounds, `&` or `|` is not allowed.

Author: nicolasstucki

src/dotty/tools/dotc/Compiler.scala

@@ -72,6 +72,7 @@ class Compiler {
            new AugmentScala2Traits, // Expand traits defined in Scala 2.11 to simulate old-style rewritings
            new ResolveSuper,        // Implement super accessors and add forwarders to trait methods
            new ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
+      List(new PhantomErasure),     // Rewrite trees erasing all values of phantom types.
       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

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

@@ -591,16 +591,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
    *  ==>

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

@@ -637,7 +637,8 @@ class Definitions {
 
   val StaticRootImportFns = List[() => TermRef](
     () => JavaLangPackageVal.termRef,
-    () => ScalaPackageVal.termRef
+    () => ScalaPackageVal.termRef,
+    () => PhantomPackageVal.termRef
   )
 
   val PredefImportFns = List[() => TermRef](
@@ -761,6 +762,8 @@ class Definitions {
     AnyValClass,
     NullClass,
     NothingClass,
+    PhantomAnyClass,
+    PhantomNothingClass,
     SingletonClass,
     EqualsPatternClass,
     EmptyPackageVal,
@@ -780,4 +783,22 @@ class Definitions {
       _isInitialized = true
     }
   }
+
+  lazy val PhantomPackageVal = ctx.requiredPackage("dotty.phantom")
+  lazy val PhantomPackageClass = PhantomPackageVal.moduleClass.asClass
+
+  lazy val PhantomAnyClass: ClassSymbol =
+    completeClass(newCompleteClassSymbol(PhantomPackageClass, tpnme.PhantomAny, Abstract, Nil))
+  def PhantomAnyType = PhantomAnyClass.typeRef
+
+  lazy val PhantomNothingClass: ClassSymbol =
+    newCompleteClassSymbol(PhantomPackageClass, tpnme.PhantomNothing, AbstractFinal, List(PhantomAnyType))
+  def PhantomNothingType = PhantomNothingClass.typeRef
+
+  lazy val Phantasmic: TermSymbol = {
+    def paramBoundsExp(gt: GenericType) = List(TypeBounds(PhantomNothingType, PhantomAnyType))
+    def resultTypeExp(gt: GenericType) = gt.paramRefs.head
+    val info = PolyType(List(tpnme.PhantasmicParam))(paramBoundsExp, resultTypeExp)
+    newMethod(PhantomPackageClass, nme.Phantasmic, info, Flags.Method)
+  }
 }

src/dotty/tools/dotc/core/Phases.scala

@@ -302,6 +302,7 @@ object Phases {
 
     private var myPeriod: Period = Periods.InvalidPeriod
     private var myBase: ContextBase = null
+    private var myErasedPhantoms = false
     private var myErasedTypes = false
     private var myFlatClasses = false
     private var myRefChecked = false
@@ -319,6 +320,7 @@ object Phases {
     def start = myPeriod.firstPhaseId
     def end = myPeriod.lastPhaseId
 
+    final def erasedPhantoms = myErasedPhantoms // Phase is after phantom erasure
     final def erasedTypes = myErasedTypes   // Phase is after erasure
     final def flatClasses = myFlatClasses   // Phase is after flatten
     final def refChecked = myRefChecked     // Phase is after RefChecks
@@ -330,6 +332,7 @@ object Phases {
         assert(myPeriod == Periods.InvalidPeriod, s"phase $this has already been used once; cannot be reused")
       myBase = base
       myPeriod = Period(NoRunId, start, end)
+      myErasedPhantoms = prev.getClass == classOf[PhantomErasure] || prev.erasedPhantoms
       myErasedTypes  = prev.getClass == classOf[Erasure]      || prev.erasedTypes
       myFlatClasses  = prev.getClass == classOf[Flatten]      || prev.flatClasses
       myRefChecked   = prev.getClass == classOf[RefChecks]    || prev.refChecked

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

@@ -224,6 +224,9 @@ object StdNames {
     final val SourceFileATTR: N             = "SourceFile"
     final val SyntheticATTR: N              = "Synthetic"
 
+    final val PhantomAny: N     = "PhantomAny"
+    final val PhantomNothing: N = "PhantomNothing"
+
 // ----- Term names -----------------------------------------
 
     // Compiler-internal
@@ -302,6 +305,9 @@ object StdNames {
     val _21 : N = "_21"
     val _22 : N = "_22"
 
+    val Phantasmic: N      = "phantasmic"
+    val PhantasmicParam: N = "Phantasmic"
+
     val ??? = encode("???")
 
     val genericWrapArray: N     = "genericWrapArray"

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

@@ -613,9 +613,18 @@ object SymDenotations {
         // after Erasure and to avoid cyclic references caused by forcing denotations
     }
 
+    /** Is this symbol a class that extends `PhantomAny`? */
+    final def isPhantomClass(implicit ctx: Context): Boolean = {
+      val di = this.initial.asSymDenotation
+      di.isClass &&
+        di.derivesFrom(defn.PhantomAnyClass)(ctx.withPhase(di.validFor.firstPhaseId))
+      // We call derivesFrom at the initial phase both because PhantomAny does not exist
+      // after PhantomErasure and to avoid cyclic references caused by forcing denotations
+    }
+
     /** 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 && !isPhantomClass && !(this is ModuleClass) && symbol != defn.NothingClass
 
     /** 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

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

@@ -49,8 +49,12 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   private var myNothingClass: ClassSymbol = null
   private var myNullClass: ClassSymbol = null
   private var myObjectClass: ClassSymbol = null
+  private var myPhantomAnyClass: ClassSymbol = null
+  private var myPhantomNothingClass: ClassSymbol = null
   private var myAnyType: TypeRef = null
   private var myNothingType: TypeRef = null
+  private var myPhantomAnyType: TypeRef = null
+  private var myPhantomNothingType: TypeRef = null
 
   def AnyClass = {
     if (myAnyClass == null) myAnyClass = defn.AnyClass
@@ -68,6 +72,14 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (myObjectClass == null) myObjectClass = defn.ObjectClass
     myObjectClass
   }
+  def PhantomAnyClass = {
+    if (myPhantomAnyClass == null) myPhantomAnyClass = defn.PhantomAnyClass
+    myPhantomAnyClass
+  }
+  def PhantomNothingClass = {
+    if (myPhantomNothingClass == null) myPhantomNothingClass = defn.PhantomNothingClass
+    myPhantomNothingClass
+  }
   def AnyType = {
     if (myAnyType == null) myAnyType = AnyClass.typeRef
     myAnyType
@@ -76,6 +88,14 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (myNothingType == null) myNothingType = NothingClass.typeRef
     myNothingType
   }
+  def PhantomAnyType = {
+    if (myPhantomAnyType == null) myPhantomAnyType = PhantomAnyClass.typeRef
+    myPhantomAnyType
+  }
+  def PhantomNothingType = {
+    if (myPhantomNothingType == null) myPhantomNothingType = PhantomNothingClass.typeRef
+    myPhantomNothingType
+  }
 
   // Subtype testing `<:<`
 
@@ -513,8 +533,17 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
             case _ => false
           }
-          (tp1.symbol eq NothingClass) && tp2.isInstanceOf[ValueType] ||
-          (tp1.symbol eq NullClass) && isNullable(tp2)
+          def isPhantom(tp: Type): Boolean = tp.dealias match {
+            case tp: TypeRef => tp.symbol.isPhantomClass
+            case tp: RefinedOrRecType => isPhantom(tp.parent)
+            case AndType(tp1, tp2) => isPhantom(tp1) && isPhantom(tp2)
+            case OrType(tp1, tp2) => isPhantom(tp1) || isPhantom(tp2)
+            case _ => false
+          }
+          if (tp1.symbol eq NothingClass) tp2.isInstanceOf[ValueType] && !isPhantom(tp2)
+          else if (tp1.symbol eq NullClass) isNullable(tp2) && !isPhantom(tp2)
+          else if (tp1.symbol eq PhantomNothingClass) tp2.isInstanceOf[ValueType] && isPhantom(tp2)
+          else false
       }
     case tp1: SingletonType =>
       /** if `tp2 == p.type` and `p: q.type` then try `tp1 <:< q.type` as a last effort.*/

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

@@ -160,7 +160,7 @@ object Types {
         case _ =>
           false
       }
-      cls == defn.AnyClass || loop(this)
+      loop(this)
     }
 
     /** Is this type guaranteed not to have `null` as a value?

src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -258,7 +258,7 @@ class TreePickler(pickler: TastyPickler) {
     case tpe: MethodType if richTypes =>
       writeByte(METHODtype)
       pickleMethodic(tpe.resultType, tpe.paramNames, tpe.paramTypes)
-    case tpe: PolyType if richTypes =>
+    case tpe: PolyType if richTypes || tpe.paramNames.contains("Phantasmic".toTypeName) => // TODO: is this the solution for phantasmic[_]?
       writeByte(POLYtype)
       pickleMethodic(tpe.resultType, tpe.paramNames, tpe.paramBounds)
     case tpe: PolyParam =>

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

@@ -32,7 +32,7 @@ class Erasure extends Phase with DenotTransformer { thisTransformer =>
   override def phaseName: String = "erasure"
 
   /** List of names of phases that should precede this phase */
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[InterceptedMethods], classOf[Splitter], classOf[ElimRepeated])
+  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PhantomErasure], classOf[InterceptedMethods], classOf[Splitter], classOf[ElimRepeated])
 
   def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {
     case ref: SymDenotation =>

src/dotty/tools/dotc/transform/PhantomErasure.scala

@@ -0,0 +1,154 @@
+package dotty.tools.dotc
+package transform
+
+import core.Phases._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Decorators._
+import dotty.tools.dotc.ast.{Trees, tpd}
+import ast.Trees._
+
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
+
+import scala.annotation.tailrec
+
+class PhantomErasure extends MiniPhaseTransform with InfoTransformer {
+  thisTransformer =>
+
+  import dotty.tools.dotc.ast.tpd._
+
+  override def phaseName: String = "phantomErasure"
+
+  /** List of names of phases that should precede this phase */
+  override def runsAfter: Set[Class[_ <: Phase]] =
+    Set(classOf[InterceptedMethods], classOf[Splitter], classOf[ElimRepeated])
+
+  /** 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 = {
+    def assertNotPhantom(tpe: Type): Unit =
+      assert(!tpe.derivesFrom(defn.PhantomAnyClass), "All phantom type values should be erased in " + tree)
+
+    tree match {
+      case _: TypeTree             =>
+      case _: Trees.TypeDef[_]     =>
+      case tree: TypeDef           => tree.symbol.asClass.classInfo.decls // TODO check decls
+      case ValDef(_, tpt, _)       => assertNotPhantom(tpt.typeOpt)
+      case DefDef(_, _, _, tpt, _) => assertNotPhantom(tpt.typeOpt)
+      case _                       => assertNotPhantom(tree.tpe)
+    }
+    super.checkPostCondition(tree)
+  }
+
+  // Transform trees
+
+  override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context, info: TransformerInfo): List[tpd.Tree] = {
+    val newTrees = trees.filter {
+      case ValDef(_, tpt, _) =>
+        !tpt.tpe.derivesFrom(defn.PhantomAnyClass)
+
+      case tree @ DefDef(_, _, _, tpt, _) =>
+        val isPhantom = tpt.tpe.derivesFrom(defn.PhantomAnyClass)
+        if (isPhantom && tree.symbol.flags.is(Flags.Accessor)) {
+          if (tree.symbol.flags.is(Flags.Mutable))
+            ctx.error("Can not define var with phantom type.", tree.pos)
+          else if (tree.symbol.flags.is(Flags.Lazy))
+            ctx.error("Can not define lazy var with phantom type.", tree.pos)
+        }
+        !isPhantom
+
+      case tree @ Apply(fun, _) if tree.tpe.derivesFrom(defn.PhantomAnyClass) =>
+        ctx.error(s"Functions returning a phantom type can not be in statement position.", fun.pos)
+        false
+      case tree @ TypeApply(fun, _) if tree.tpe.derivesFrom(defn.PhantomAnyClass) =>
+        ctx.error(s"Functions returning a phantom type can not be in statement position.", fun.pos)
+        false
+      case tree: Select if tree.tpe.derivesFrom(defn.PhantomAnyClass) =>
+        ctx.error(s"Fields containing a phantom type can not be accessed in statement position.", tree.pos)
+        false
+
+      case _ =>
+        true
+    }
+    super.transformStats(newTrees)
+  }
+
+  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val paramTypes = {
+      tree.fun.typeOpt match {
+        case tpe: TermRef =>
+          tpe.info match {
+            case tpe2: MethodType => tpe2.paramTypes
+            case _ => Nil
+          }
+
+        case tpe: MethodType => tpe.paramTypes
+        case _ => Nil
+      }
+    }
+
+    val newTree =
+      if (paramTypes.nonEmpty || tree.args.isEmpty) tree
+      else cpy.Apply(tree)(tree.fun, Nil)
+
+    super.transformApply(newTree)
+  }
+
+  override def transformDefDef(ddef: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    def filterPhantom(vparamss: List[List[ValDef]]): List[List[ValDef]] = {
+      vparamss.filter { vparams =>
+        val phantoms = vparams.filter(_.tpt.typeOpt.derivesFrom(defn.PhantomAnyClass))
+        if (phantoms.nonEmpty && phantoms.size != vparams.size)
+          ctx.error("Lists of parameters with runtime and phantom types are not allowed.", vparams.head.pos)
+        phantoms.isEmpty
+      }
+    }
+    val newVparamss = filterPhantom(ddef.vparamss)
+    val ddef1 =
+      if (ddef.vparamss.length == newVparamss.length) ddef
+      else cpy.DefDef(ddef)(vparamss = newVparamss)
+    super.transformDefDef(ddef1)
+  }
+
+  // Transform symbols
+
+  def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = erasedPhantoms(tp)
+
+  private def erasedPhantoms(tp: Type)(implicit ctx: Context): Type = {
+    val flags = tp.typeSymbol.flags
+    tp match {
+      case tp: ClassInfo if !flags.is(Flags.Package) =>
+        val newDecls = tp.decls.filteredScope(sym => !isPhantomMethodType(sym.info))
+        ClassInfo(tp.prefix, tp.cls, tp.classParents, newDecls, tp.selfInfo)
+
+      case tp: JavaMethodType => tp
+      case tp: MethodType => erasedMethodPhantoms(tp)
+
+      case tp: PolyType =>
+        PolyType(tp.paramNames)(_ => tp.paramBounds, _ => erasedPhantoms(tp.resType))
+
+      case _ => tp
+    }
+  }
+
+  private def erasedMethodPhantoms(tp: MethodType)(implicit ctx: Context): MethodType = {
+    val (erasedParamNames, erasedParamTypes) =
+      if (tp.paramTypes.isEmpty || tp.paramTypes.head.derivesFrom(defn.PhantomAnyClass)) (Nil, Nil)
+      else (tp.paramNames, tp.paramTypes)
+    val erasedResultType = erasedPhantoms(tp.resultType)
+    tp match {
+      case _: ImplicitMethodType =>
+        ImplicitMethodType(erasedParamNames, erasedParamTypes, erasedResultType)
+      case _ =>
+        MethodType(erasedParamNames, erasedParamTypes, erasedResultType)
+    }
+  }
+
+  @tailrec private def isPhantomMethodType(tpe: Type)(implicit ctx: Context): Boolean = tpe match {
+    case tpe: MethodicType => tpe.resultType.derivesFrom(defn.PhantomAnyClass) || isPhantomMethodType(tpe.resultType)
+    case _                 => false
+  }
+}

src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -304,7 +304,7 @@ class TreeChecker extends Phase with SymTransformer {
             mapOver(tp)
             definedBinders -= tp
           case tp: ParamType =>
-            assert(definedBinders.contains(tp.binder), s"orphan param: $tp")
+            assert(definedBinders.contains(tp.binder) || (tp.derivesFrom(defn.PhantomAnyClass) && ctx.phase.erasedPhantoms), s"orphan param: $tp")
           case tp: TypeVar =>
             apply(tp.underlying)
           case _ =>