Don't generate fields for BoxedUnit val and var

This is intended as a way to not generate fields
for phantom fields, which by this time are erased
to BoxedUnit fields.

Author: nicolasstucki

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

@@ -9,8 +9,8 @@ import dotty.tools.dotc.core.Types.Type
  *
  *  - Parameters/arguments are erased to BoxedUnit. The next step will remove the parameters
  *    from the method definitions and calls (implemented in branch implement-phantom-types-part-2).
- *  - Definitions of `def`, `val`, `lazy val` and `var` returning a phantom type to return a BoxedUnit. The next step
- *    is to erase the fields for phantom types (implemented in branch implement-phantom-types-part-3)
+ *  - Definitions of `def`, `val`, `lazy val` and `var` returning a phantom type to return a BoxedUnit. Where fields
+ *    with BoxedUnit type are not memoized (see transform/Memoize.scala).
  *  - Calls to Phantom.assume become calls to BoxedUnit. Intended to be optimized away by local optimizations.
  *
  *  BoxedUnit is used as it fits perfectly and homogeneously in all locations where phantoms can be found.

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

@@ -103,13 +103,20 @@ import Decorators._
         var rhs = tree.rhs.changeOwnerAfter(sym, field, thisTransform)
         if (isWildcardArg(rhs)) rhs = EmptyTree
         val fieldDef = transformFollowing(ValDef(field, adaptToField(rhs)))
-        val getterDef = cpy.DefDef(tree)(rhs = transformFollowingDeep(ref(field))(ctx.withOwner(sym), info))
+        val isUnitField = tree.tpt.tpe.widenDealias =:= defn.BoxedUnitType
+        val getterRhs =
+          if (isUnitField) ref(defn.BoxedUnit_UNIT)
+          else transformFollowingDeep(ref(field))(ctx.withOwner(sym), info)
+        val getterDef = cpy.DefDef(tree)(rhs = getterRhs)
         Thicket(fieldDef, getterDef)
       } else if (sym.isSetter) {
         if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs } // this is intended as an assertion
         field.setFlag(Mutable) // necessary for vals mixed in from Scala2 traits
-        val initializer = Assign(ref(field), adaptToField(ref(tree.vparamss.head.head.symbol)))
-        cpy.DefDef(tree)(rhs = transformFollowingDeep(initializer)(ctx.withOwner(sym), info))
+        if (tree.vparamss.head.head.tpt.tpe =:= defn.BoxedUnitType) tree
+        else {
+          val initializer = Assign(ref(field), adaptToField(ref(tree.vparamss.head.head.symbol)))
+          cpy.DefDef(tree)(rhs = transformFollowingDeep(initializer)(ctx.withOwner(sym), info))
+        }
       }
       else tree // curiously, some accessors from Scala2 have ' ' suffixes. They count as
                 // neither getters nor setters

tests/run/phantom-lazy-val-2.check

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

tests/run/phantom-lazy-val-2.scala

@@ -0,0 +1,29 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    val f = new Foo
+    println(1)
+    f.foo
+    println(2)
+    f.foo
+    // Currently not erasing fields for lazy phantom vals
+    // assert(!f.getClass.getDeclaredFields.exists(_.getName.startsWith("foo")), "field foo not erased")
+  }
+
+
+}
+
+class Foo {
+  import Boo._
+
+  lazy val foo = {
+    println("foo")
+    any
+  }
+}
+
+object Boo extends Phantom {
+  type BooAny = this.Any
+  def any: BooAny = assume
+}

tests/run/phantom-val-2.check

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

tests/run/phantom-val-2.scala

@@ -0,0 +1,23 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val f = new Foo
+    println(1)
+    f.foo
+    f.foo
+    assert(!f.getClass.getDeclaredFields.exists(_.getName.startsWith("foo")), "field foo not erased")
+  }
+}
+
+class Foo {
+  import Boo._
+  val foo = {
+    println("foo")
+    any
+  }
+}
+
+object Boo extends Phantom {
+  type BooAny = this.Any
+  def any: BooAny = assume
+}

tests/run/phantom-var-2.check

@@ -0,0 +1,3 @@
+foo
+foo2
+foo3

tests/run/phantom-var-2.scala

@@ -0,0 +1,35 @@
+
+object Test {
+  import Boo._
+
+  def main(args: Array[String]): Unit = {
+    val f = new Foo
+    f.foo
+    f.foo
+    f.foo = {
+      println("foo3")
+      any
+    }
+    f.foo
+    assert(!f.getClass.getDeclaredFields.exists(_.getName.startsWith("foo")), "field foo not erased")
+  }
+}
+
+class Foo {
+  import Boo._
+
+  var foo = {
+    println("foo")
+    any
+  }
+
+  foo = {
+    println("foo2")
+    any
+  }
+}
+
+object Boo extends Phantom {
+  type BooAny = this.Any
+  def any: BooAny = assume
+}

tests/run/unit-lazy-val.check

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

tests/run/unit-lazy-val.scala

@@ -0,0 +1,21 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    val f = new Foo
+    println(1)
+    f.foo
+    println(2)
+    f.foo
+    // Currently not erasing fields for lazy vals
+    // assert(!f.getClass.getDeclaredFields.exists(_.getName.startsWith("foo")), "field foo not erased")
+  }
+
+
+}
+
+class Foo {
+  lazy val foo: Unit = {
+    println("foo")
+  }
+}

tests/run/unit-val.check

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

tests/run/unit-val.scala

@@ -0,0 +1,16 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val f = new Foo
+    println(1)
+    f.foo
+    f.foo
+    assert(!f.getClass.getDeclaredFields.exists(_.getName.startsWith("foo")), "field foo not erased")
+  }
+}
+
+class Foo {
+  val foo: Unit = {
+    println("foo")
+  }
+}

tests/run/unit-var.check

@@ -0,0 +1,3 @@
+foo
+foo2
+foo3

tests/run/unit-var.scala

@@ -0,0 +1,23 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val f = new Foo
+    f.foo
+    f.foo
+    f.foo = {
+      println("foo3")
+    }
+    f.foo
+    assert(!f.getClass.getDeclaredFields.exists(_.getName.startsWith("foo")), "field foo not erased")
+  }
+}
+
+class Foo {
+  var foo: Unit = {
+    println("foo")
+  }
+
+  foo = {
+    println("foo2")
+  }
+}