Make all phantoms unused

This removes the necesity of erasing phantoms. This process
is done by the erasure of `unused`.

Author: nicolasstucki

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

@@ -68,8 +68,7 @@ class Compiler {
            new ShortcutImplicits,   // Allow implicit functions without creating closures
            new CrossCastAnd,        // Normalize selections involving intersection types.
            new Splitter),           // Expand selections involving union types into conditionals
-      List(new PhantomArgLift,      // Extracts the evaluation of phantom arguments placing them before the call
-           new UnusedDecls,         // Removes all unused defs and vals decls (except for parameters)
+      List(new UnusedDecls,         // Removes all unused defs and vals decls (except for parameters)
            new VCInlineMethods,     // Inlines calls to value class methods
            new SeqLiterals,         // Express vararg arguments as arrays
            new InterceptedMethods,  // Special handling of `==`, `|=`, `getClass` methods

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

@@ -437,6 +437,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     else if (tpw isRef defn.DoubleClass) Literal(Constant(0d))
     else if (tpw isRef defn.ByteClass) Literal(Constant(0.toByte))
     else if (tpw isRef defn.ShortClass) Literal(Constant(0.toShort))
+    else if (tpw.isPhantom) Literal(Constant(null)).withType(tpw)
     else Literal(Constant(null)).select(defn.Any_asInstanceOf).appliedToType(tpe)
   }
 

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

@@ -1109,21 +1109,15 @@ class Definitions {
 
     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_, ExprType(nothing.typeRef), Protected | Final | Method)
+    enterMethod(cls, nme.assume_, ExprType(nothing.typeRef), Protected | Final | Method | Unused)
 
     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)
 
-
   lazy val ErasedPhantomType: TypeRef = ctx.requiredClassRef("dotty.runtime.ErasedPhantom")
-  def ErasedPhantomClass(implicit ctx: Context) = ErasedPhantomType.symbol.asClass
-
-  def ErasedPhantom_UNIT(implicit ctx: Context) = ErasedPhantomClass.linkedClass.requiredValue("UNIT")
-
 }

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

@@ -84,7 +84,7 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
    *  to the parameter part of this signature.
    */
   def prepend(params: List[Type], isJava: Boolean)(implicit ctx: Context) =
-    Signature(params.collect { case p if !p.isPhantom => sigName(p, isJava) } ++ paramsSig, resSig)
+    Signature(params.map(p => sigName(p, isJava)) ++ paramsSig, resSig)
 
   /** A signature is under-defined if its paramsSig part contains at least one
    *  `tpnme.Uninstantiated`. Under-defined signatures arise when taking a signature

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

@@ -378,7 +378,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(sym)) PhantomErasure.erasedPhantomType
+      else if (defn.isPhantomTerminalClass(sym)) defn.ErasedPhantomType
       else if (sym eq defn.PhantomClass) defn.ObjectType // To erase the definitions of Phantom.{assume, Any, Nothing}
       else eraseNormalClassRef(tp)
     case tp: AppliedType =>
@@ -399,10 +399,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
         erasureFn(tp.isJavaMethod, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
-      val (names, formals0) =
-        if (tp.isUnusedMethod) (Nil, Nil)
-        else if (tp.paramInfos.exists(_.isPhantom)) tp.paramNames.zip(tp.paramInfos).filterNot(_._2.isPhantom).unzip
-        else (tp.paramNames, tp.paramInfos)
+      val (names, formals0) = if (tp.isUnusedMethod) (Nil, Nil) else (tp.paramNames, tp.paramInfos)
       val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>
@@ -520,8 +517,6 @@ 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 tp: AppliedType =>

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

@@ -129,7 +129,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
     // Produce aligned accessors and constructor parameters. We have to adjust
     // for any outer parameters, which are last in the sequence of original
     // parameter accessors but come first in the constructor parameter list.
-    val accessors = cls.paramAccessors.filterNot(x => x.isSetter || x.info.resultType.classSymbol == defn.ErasedPhantomClass)
+    val accessors = cls.paramAccessors.filterNot(x => x.isSetter)
     val vparamsWithOuterLast = vparams match {
       case vparam :: rest if vparam.name == nme.OUTER => rest ::: vparam :: Nil
       case _ => vparams

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

@@ -28,7 +28,6 @@ import ValueClasses._
 import TypeUtils._
 import ExplicitOuter._
 import core.Mode
-import core.PhantomErasure
 import reporting.trace
 
 class Erasure extends Phase with DenotTransformer {
@@ -210,8 +209,6 @@ object Erasure {
           val tree1 =
             if (tree.tpe isRef defn.NullClass)
               adaptToType(tree, underlying)
-            else if (wasPhantom(underlying))
-              PhantomErasure.erasedParameterRef
             else if (!(tree.tpe <:< tycon)) {
               assert(!(tree.tpe.typeSymbol.isPrimitiveValueClass))
               val nullTree = Literal(Constant(null))
@@ -427,16 +424,9 @@ object Erasure {
         }
       }
 
-      if ((origSym eq defn.Phantom_assume) || (origSym.is(Flags.ParamAccessor) && wasPhantom(pt)))
-        PhantomErasure.erasedAssume
-      else recur(typed(tree.qualifier, AnySelectionProto))
+      recur(typed(tree.qualifier, AnySelectionProto))
     }
 
-    override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context): tpd.Tree =
-      if (tree.symbol eq defn.Phantom_assume) PhantomErasure.erasedAssume
-      else if (tree.symbol.is(Flags.Param) && wasPhantom(tree.typeOpt)) PhantomErasure.erasedParameterRef
-      else super.typedIdent(tree, pt)
-
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =
       if (tree.symbol == ctx.owner.lexicallyEnclosingClass || tree.symbol.isStaticOwner) promote(tree)
       else {
@@ -496,11 +486,9 @@ object Erasure {
                   .withType(defn.ArrayOf(defn.ObjectType))
                 args0 = bunchedArgs :: Nil
               }
-              // Arguments are phantom if an only if the parameters are phantom, guaranteed by the separation of type lattices
-              val args1 = args0.filterConserve(arg => !wasPhantom(arg.typeOpt))
-              assert(args1 hasSameLengthAs mt.paramInfos)
-              val args2 = args1.zipWithConserve(mt.paramInfos)(typedExpr)
-              untpd.cpy.Apply(tree)(fun1, args2) withType mt.resultType
+              assert(args0 hasSameLengthAs mt.paramInfos)
+              val args1 = args0.zipWithConserve(mt.paramInfos)(typedExpr)
+              untpd.cpy.Apply(tree)(fun1, args1) withType mt.resultType
             case _ =>
               throw new MatchError(i"tree $tree has unexpected type of function ${fun1.tpe.widen}, was ${fun.typeOpt.widen}")
           }
@@ -561,11 +549,6 @@ object Erasure {
         rhs1 = untpd.Block(paramDefs, rhs1)
       }
       vparamss1 = vparamss1.mapConserve(_.filterConserve(!_.symbol.is(Flags.Unused)))
-      vparamss1 = vparamss1.mapConserve(_.filterConserve(vparam => !wasPhantom(vparam.tpe)))
-      if (sym.is(Flags.ParamAccessor) && wasPhantom(ddef.tpt.tpe)) {
-        sym.resetFlag(Flags.ParamAccessor)
-        rhs1 = PhantomErasure.erasedParameterRef
-      }
       val ddef1 = untpd.cpy.DefDef(ddef)(
         tparams = Nil,
         vparamss = vparamss1,
@@ -680,7 +663,4 @@ object Erasure {
 
   def takesBridges(sym: Symbol)(implicit ctx: Context) =
     sym.isClass && !sym.is(Flags.Trait | Flags.Package)
-
-  private def wasPhantom(tp: Type)(implicit ctx: Context): Boolean =
-    tp.widenDealias.classSymbol eq defn.ErasedPhantomClass
 }

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

@@ -174,14 +174,6 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
     } else ddef
   }
 
-  override def transformValDef(vdef: tpd.ValDef)(implicit ctx: Context): tpd.Tree = {
-    if (vdef.tpt.tpe.isPhantom) {
-      if (vdef.symbol.is(Mutable)) ctx.error("var fields cannot have Phantom types", vdef.pos)
-      else if (vdef.symbol.hasAnnotation(defn.VolatileAnnot)) ctx.error("Phantom fields cannot be @volatile", vdef.pos)
-    }
-    vdef
-  }
-
   override def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
     ast.Trees.flatten(reorderAndComplete(trees)(ctx.withPhase(thisPhase.next)))
 

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

@@ -107,7 +107,6 @@ import Decorators._
       if (sym eq defn.NothingClass) Throw(Literal(Constant(null)))
       else if (sym eq defn.NullClass) Literal(Constant(null))
       else if (sym eq defn.BoxedUnitClass) ref(defn.BoxedUnit_UNIT)
-      else if (sym eq defn.ErasedPhantomClass) ref(defn.ErasedPhantom_UNIT)
       else {
         assert(false, sym + " has no erased bottom tree")
         EmptyTree
@@ -120,11 +119,8 @@ import Decorators._
       def adaptToField(tree: Tree): Tree =
         if (tree.isEmpty) tree else tree.ensureConforms(field.info.widen)
 
-      def isErasableBottomField(cls: Symbol): Boolean = {
-        // TODO: For Scala.js, return false if this field is in a js.Object unless it is an ErasedPhantomClass.
-        !field.isVolatile &&
-        ((cls eq defn.NothingClass) || (cls eq defn.NullClass) || (cls eq defn.BoxedUnitClass) || (cls eq defn.ErasedPhantomClass))
-      }
+      def isErasableBottomField(cls: Symbol): Boolean =
+        !field.isVolatile && ((cls eq defn.NothingClass) || (cls eq defn.NullClass) || (cls eq defn.BoxedUnitClass))
 
       if (sym.isGetter) {
         var rhs = tree.rhs.changeOwnerAfter(sym, field, thisPhase)

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

@@ -163,7 +163,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
       val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.pos) // x$0
       def wildcardAscription(tp: Type) = Typed(Underscore(tp), TypeTree(tp))
       val pattern = Bind(thatAsClazz, wildcardAscription(clazzType)) // x$0 @ (_: C)
-      val comparisons = accessors collect { case accessor if !accessor.info.isPhantom =>
+      val comparisons = accessors map { accessor =>
         This(clazz).select(accessor).select(defn.Any_==).appliedTo(ref(thatAsClazz).select(accessor)) }
       val rhs = // this.x == this$0.x && this.y == x$0.y
         if (comparisons.isEmpty) Literal(Constant(true)) else comparisons.reduceLeft(_ and _)
@@ -191,7 +191,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
      */
     def valueHashCodeBody(implicit ctx: Context): Tree = {
       assert(accessors.nonEmpty)
-      assert(accessors.tail.forall(a => a.info.isPhantom || a.is(Unused)))
+      assert(accessors.tail.forall(_ is Unused))
       ref(accessors.head).select(nme.hashCode_).ensureApplied
     }
 

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

@@ -11,7 +11,6 @@ import core.NameOps._
 import transform.MegaPhase.MiniPhase
 import config.Printers.simplify
 import ast.tpd
-import dotty.tools.dotc.core.PhantomErasure
 
 import scala.annotation.tailrec
 
@@ -184,8 +183,6 @@ object Simplify {
                             sym.owner.is(CaseClass)                  &&
                             sym.name.isSelectorName                  &&
                             !sym.info.decls.exists(_.is(Mutable | Lazy)) // Conservatively covers case class A(var x: Int)
-    val isErasedPhantom   = PhantomErasure.isErasedPhantom(sym)
-
-    isImmutableGetter || isCaseAccessor || isProductAccessor || isErasedPhantom
+    isImmutableGetter || isCaseAccessor || isProductAccessor
   }
 }

compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala

@@ -500,12 +500,10 @@ object Checking {
           case param :: params =>
             if (param.is(Mutable))
               ctx.error(ValueClassParameterMayNotBeAVar(clazz, param), param.pos)
-            if (param.info.isPhantom)
-              ctx.error("value class first parameter must not be phantom", param.pos)
-            else if (param.is(Unused))
+            if (param.is(Unused))
               ctx.error("value class first parameter cannot be `unused`", param.pos)
             else {
-              for (p <- params if !(p.info.isPhantom || p.is(Unused)))
+              for (p <- params if !p.is(Unused))
                 ctx.error("value class can only have one non `unused` parameter", p.pos)
             }
           case Nil =>

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

@@ -68,7 +68,7 @@ package scala
 trait Phantom { // only an `object` can extend this trait
   protected final type Any // not a subtype of scala.Any
   protected final type Nothing // subtype of every subtype of this.Any
-  protected final def assume: this.Nothing
+  protected final unused def assume: this.Nothing
 }
 ```
 
@@ -102,8 +102,8 @@ precise type. In our example we will only create values of type `Pinky` and `Cly
 object MyPhantoms extends Phantom {
   ... // Type definition
 
-  def pinky: Pinky = assume
-  def clyde: Clyde = assume
+  unused def pinky: Pinky = assume
+  unused def clyde: Clyde = assume
 }
 ```
 
@@ -115,8 +115,8 @@ We can look at the following simple application:
 ```scala
 import MyPhantoms._
 object MyApp {
-  def run(phantom: Inky) = println("run")
-  def hide(phantom: Blinky) = println("run")
+  def run(unused phantom: Inky) = println("run")
+  def hide(unused phantom: Blinky) = println("run")
 
   run(pinky)
   run(clyde)
@@ -134,48 +134,4 @@ mistakes before when compiling the code, no surprises at runtime (hopefully not
 What happens with Phantoms at runtime?
 --------------------------------------
 
-Disclaimer: Most of phantom erasure is implemented, but not all of is has been merged in `dotty/master` yet.
-
-As phantom have no effect on the result of a method invocation we just remove them for the call an definition. 
-The evaluation of the phantom parameter is still be done unless it can be optimized away. 
-By removing them we also restrict overloading as `def f()` and `def f(x: MyPhantom)` will 
-have the same signature in the bytecode, just use different names to avoid this.
-
-At runtime the `scala.Phantom` trait will not exist.
-* The object extending `Phantom` will not extend it anymore
-* All phantom types will be erased on a single erased type (important in overloading for methods returning a phantom)
-* Calls to `Phantom.assume` will become a reference to a singleton of the erased phantom type and will be removed wherever possible
-
-```scala
-object MyOtherPhantom extends Phantom {
-  type MyPhantom <: this.Any
-  def myPhantom: MyPhantom = assume
-
-  def f1(a: Int, b: MyPhantom, c: Int): Int = a + c
-
-  def f2 = {
-    f1(3, myPhantom, 2)
-  }
-}
-```
-
-will be compiled to
-
-```scala
-object MyOtherPhantom {
-  def myPhantom(): <ErasedPhantom> = <ErasedPhantom.UNIT>
-
-  def f1(a: Int, c: Int): Int = a + c
-
-  def f2 = {
-    val a$ = 3
-    myPhantom()
-    val b$ = 3
-    f1(a$, b$)
-  }
-}
-```
-
-Note that `myPhantom` is not removed as it could have some side effect before returning the phantom. 
-To remove it just use `inline def myPhantom` instead this will remove the call and allow the 
-`<ErasedPhantom.UNIT>` to be optimized away.
+All phantoms are erased using the `unused` keyword. Theyb will simply not exist at runtime.

docs/docs/reference/phantom-types.md

@@ -0,0 +1,4 @@
+package dotty.runtime
+
+/** Type representing an erased phantom type */
+final abstract class ErasedPhantom