Erase phantom fields.

Erase all `val` and `var` of phantom type. `lazy val` are not transformed as their expansion is done in the backend.

Erasure:
* Assignments are replaced by their RHS
* Local `val` and `var` definitions are replaced by their RHS
* Fields are removed
* Getters return `null.asInstanceOf[dotty.runtime.ErasedPhantom]`

Tests for this commit where added in `Extra tests for Phantoms 2`, they where back ported as the semantics and runtime is not affected.

Author: nicolasstucki

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

@@ -94,6 +94,7 @@ class Compiler {
       List(new LambdaLift,          // Lifts out nested functions to class scope, storing free variables in environments
                                        // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
            new ElimStaticThis,      // Replace `this` references to static objects by global identifiers
+           new PhantomVals,         // Remove ValDefs of phantom type
            new Flatten,             // Lift all inner classes to package scope
            new RestoreScopes),      // Repair scopes rendered invalid by moving definitions in prior phases of the group
       List(new MoveStatics,         // Move static methods to companion classes

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

@@ -0,0 +1,59 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import DenotTransformers._
+import Phases.Phase
+import Contexts.Context
+import Symbols._
+import Constants._
+import TreeTransforms._
+import Flags._
+
+/** Erases all ValDefs of phantom type,
+ *  except for `lazy val` as the field are not yet generated.
+ *
+ *    <accessor> <mods> def x(): ErasedPhantom = e
+ *      --> <accessor> <mods> def x(): ErasedPhantom = null
+ *
+ *
+ *    x = e  --> e  where type of x is ErasedPhantom
+ *
+ *    Filed in class
+ *    <private> <mods> val x: ErasedPhantom --> EmptyTree
+ *
+ *    Field in method
+ *    <mods> val x: ErasedPhantom = e --> e
+ */
+ class PhantomVals extends MiniPhaseTransform with IdentityDenotTransformer { thisTransform =>
+  import ast.tpd._
+
+  override def phaseName = "phantomVals"
+
+  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
+    // TODO
+  }
+
+  override def runsAfterGroupsOf: Set[Class[_ <: Phase]] = Set(classOf[Constructors])
+
+  override def transformValDef(tree: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val sym = tree.symbol
+    if (sym.is(Lazy) || !(tree.tpt.tpe =:= defn.ErasedPhantomType)) tree
+    else if (sym.is(Private)) EmptyTree
+    else tree.rhs
+  }
+
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val sym = tree.symbol
+    if (sym.isGetter && !sym.is(Lazy) && (tree.tpt.tpe =:= defn.ErasedPhantomType)) {
+      cpy.DefDef(tree)(rhs = Literal(Constant(null)).withType(defn.ErasedPhantomType))
+    } else tree
+  }
+
+  override def transformAssign(tree: Assign)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val lhsSym = tree.lhs.symbol
+    if (!lhsSym.is(Lazy) && tree.rhs.tpe =:= defn.ErasedPhantomType) tree.rhs
+    else tree
+  }
+
+}