Erase phantom fields.

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 ExpandPrivate,       // Widen private definitions accessed from nested 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
+  }
+
+}

tests/run/phantom-lazy-val.check

@@ -0,0 +1,3 @@
+1
+foo
+2

tests/run/phantom-lazy-val.scala

@@ -0,0 +1,27 @@
+
+/* Run this test with
+ *   `run tests/run/xyz.scala -Xprint-diff-del -Xprint:arrayConstructors,phantomTermErasure,phantomTypeErasure,erasure`
+ * to see the the diffs after PhantomRefErasure, PhantomDeclErasure and Erasure.
+ */
+
+object Test {
+  import Boo._
+
+  def main(args: Array[String]): Unit = {
+    println(1)
+    foo
+    println(2)
+    foo
+  }
+
+  lazy val foo = {
+    println("foo")
+    any
+  }
+
+}
+
+object Boo extends Phantom {
+  type BooAny = this.Any
+  def any: BooAny = assume[BooAny]
+}

tests/run/phantom-val.check

@@ -0,0 +1,2 @@
+foo
+1

tests/run/phantom-val.scala

@@ -0,0 +1,26 @@
+
+/* Run this test with
+ *   `run tests/run/xyz.scala -Xprint-diff-del -Xprint:arrayConstructors,phantomTermErasure,phantomTypeErasure,erasure`
+ * to see the the diffs after PhantomRefErasure, PhantomDeclErasure and Erasure.
+ */
+
+object Test {
+  import Boo._
+
+  def main(args: Array[String]): Unit = {
+    println(1)
+    foo
+    foo
+
+  }
+
+  val foo = {
+    println("foo")
+    any
+  }
+}
+
+object Boo extends Phantom {
+  type BooAny = this.Any
+  def any: BooAny = assume[BooAny]
+}

tests/run/phantom-var.check

@@ -0,0 +1,2 @@
+foo
+foo2

tests/run/phantom-var.scala

@@ -0,0 +1,30 @@
+
+/* Run this test with
+ *   `run tests/run/xyz.scala -Xprint-diff-del -Xprint:arrayConstructors,phantomTermErasure,phantomTypeErasure,erasure`
+ * to see the the diffs after PhantomRefErasure, PhantomDeclErasure and Erasure.
+ */
+
+object Test {
+  import Boo._
+
+  def main(args: Array[String]): Unit = {
+    foo
+    foo
+    foo = {
+      println("foo2")
+      any
+    }
+    foo
+
+  }
+
+  var foo = {
+    println("foo")
+    any
+  }
+}
+
+object Boo extends Phantom {
+  type BooAny = this.Any
+  def any: BooAny = assume[BooAny]
+}