Erase arguments of phantom type

This commit removes arguments and parameter of phantom type from all applications.
Arguments are evaluated before the application in case they have side effects.

```
def foo(i: Int, p: SomePhantom) = ???

foo(42, { println("hello"); getSomePhantom })
```

becomes

```
def foo(i: Int) = ???

val x$0 = 42
val x$1 = { println("hello"); getSomePhantom }
foo(x$0)
```

Note that now `def foo(i: Int)` and def `foo(i: Int, p: SomePhantom)` erase to the same signature.

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

Author: nicolasstucki

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

@@ -66,7 +66,8 @@ 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 VCInlineMethods,     // Inlines calls to value class methods
+      List(new PhantomArgumentEval, // Extracts the evaluation of phantom arguments placing them before the call.
+           new VCInlineMethods,     // Inlines calls to value class methods
            new IsInstanceOfEvaluator, // Issues warnings when unreachable statements are present in match/if expressions
            new SeqLiterals,         // Express vararg arguments as arrays
            new InterceptedMethods,  // Special handling of `==`, `|=`, `getClass` methods

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

@@ -5,10 +5,13 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Symbols.defn
 import dotty.tools.dotc.core.Types.Type
 
-/** Phantom erasure erases (minimal erasure):
+/** Phantom erasure erases:
  *
- *  - 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).
+ *  - Parameters/arguments are erased removed from the function definition/call in `PhantomArgumentEval`.
+ *    If the evaluation of the phantom arguments may produce a side effect, these are evaluated and stored in
+ *    local `val`s and then the non phantoms are used in the Apply. Phantom `val`s are then erased to
+ *    `val ev$i: BoxedUnit = myPhantom` intended to be optimized away by local optimizations. `myPhantom` could be
+ *    a reference to a phantom parameter, a call to Phantom assume or a call to a method that returns a phantom.
  *  - 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)
  *  - Calls to Phantom.assume become calls to BoxedUnit. Intended to be optimized away by local optimizations.
@@ -25,4 +28,7 @@ object PhantomErasure {
   /** Returns the default erased tree for a call to Phantom.assume */
   def erasedAssume(implicit ctx: Context): Tree = ref(defn.BoxedUnit_UNIT)
 
+  /** Returns the default erased tree for a phantom parameter ref */
+  def erasedParameterRef(implicit ctx: Context): Tree = ref(defn.BoxedUnit_UNIT)
+
 }

compiler/src/dotty/tools/dotc/core/Signature.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.map(sigName(_, isJava))) ++ paramsSig, resSig)
+    Signature(params.collect { case p if !p.isPhantom => 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/TypeErasure.scala

@@ -385,12 +385,15 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
         erasureFn(tp.isJava, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
-      val formals = tp.paramInfos.mapConserve(paramErasure)
+      val (names, formals0) =
+        if (tp.paramInfos.forall(!_.isPhantom)) (tp.paramNames, tp.paramInfos)
+        else tp.paramNames.iterator.zip(tp.paramInfos.iterator).filterNot(_._2.isPhantom).toList.unzip
+      val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>
-          tp.derivedLambdaType(tp.paramNames ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType)
+          tp.derivedLambdaType(names ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType)
         case rt =>
-          tp.derivedLambdaType(tp.paramNames, formals, rt)
+          tp.derivedLambdaType(names, formals, rt)
       }
     case tp: PolyType =>
       this(tp.resultType)

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

@@ -470,7 +470,7 @@ object Erasure extends TypeTestsCasts{
                   .withType(defn.ArrayOf(defn.ObjectType))
                 args0 = bunchedArgs :: Nil
               }
-              val args1 = args0.zipWithConserve(mt.paramInfos)(typedExpr)
+              val args1 = args0.filterConserve(arg => !wasPhantom(arg.typeOpt)).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}")
@@ -485,6 +485,10 @@ object Erasure extends TypeTestsCasts{
       super.typedSeqLiteral(tree, erasure(tree.typeOpt))
         // proto type of typed seq literal is original type;
 
+    override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context) =
+      if (tree.symbol.is(Flags.Param) && wasPhantom(tree.typeOpt)) PhantomErasure.erasedParameterRef
+      else super.typedIdent(tree, pt)
+
     override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context) =
       super.typedIf(tree, adaptProto(tree, pt))
 
@@ -531,6 +535,7 @@ object Erasure extends TypeTestsCasts{
         vparamss1 = (tpd.ValDef(bunchedParam) :: Nil) :: Nil
         rhs1 = untpd.Block(paramDefs, rhs1)
       }
+      vparamss1 = vparamss1.mapConserve(_.filterConserve(vparam => !wasPhantom(vparam.tpe)))
       val ddef1 = untpd.cpy.DefDef(ddef)(
         tparams = Nil,
         vparamss = vparamss1,
@@ -614,4 +619,6 @@ object Erasure extends TypeTestsCasts{
 
   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.isPhantom(ctx.withPhase(ctx.erasurePhase))
 }

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

@@ -0,0 +1,105 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameKinds._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+
+/** This phase extracts the arguments of phantom type before the application to avoid losing any
+ *  effects in the argument tree. This trivializes the removal of parameter in the Erasure phase.
+ *
+ *  `f(x1,...)(y1,...)...(...)` with at least one phantom argument
+ *
+ *    -->
+ *
+ *  `val ev$f = f` // if `f` is some expression that needs evaluation
+ *  `val ev$x1 = x1`
+  *  ...
+ *  `val ev$y1 = y1`
+  *  ...
+ *  `ev$f(ev$x1,...)(ev$y1,...)...(...)`
+ *
+ */
+class PhantomArgumentEval extends MiniPhaseTransform {
+  import tpd._
+
+  override def phaseName: String = "phantomArgumentEval"
+
+  /** Check what the phase achieves, to be called at any point after it is finished. */
+  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
+    case tree: Apply =>
+      tree.args.foreach { arg =>
+        assert(
+          !arg.tpe.isPhantom ||
+          (arg.isInstanceOf[Ident] && !arg.symbol.is(Method) && !arg.symbol.is(Lazy))
+        )
+      }
+    case _ =>
+  }
+
+  /* Tree transform */
+
+  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = tree.tpe match {
+    case _: MethodType => tree // Do the transformation higher in the tree if needed
+    case _ =>
+      def mkNewBlock(newApply: Tree, synthVals: List[ValDef]) = Block(synthVals, newApply)
+      if (!hasPhantomArgs(tree)) tree
+      else transformApplication(tree, mkNewBlock)
+  }
+
+  override def transformAssign(tree: Assign)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    if (!tree.rhs.tpe.isPhantom) super.transformAssign(tree)
+    else {
+      // Apply the same transformation to setters before their creation.
+      val (synthVal, synthValRef) = mkSynthVal(tree.rhs)
+      Block(List(synthVal), Assign(tree.lhs, synthValRef))
+    }
+  }
+
+  /* private methods */
+
+  /** Returns true if at least on of the arguments is a phantom.
+   *  Inner applies are also checked in case of multiple parameter list.
+   */
+  private def hasPhantomArgs(tree: Apply)(implicit ctx: Context): Boolean = {
+    tree.args.exists {
+      case arg: Ident if !arg.symbol.is(Method) && !arg.symbol.is(Lazy) => false
+      case arg => arg.tpe.isPhantom
+    } || {
+      tree.fun match {
+        case fun: Apply => hasPhantomArgs(fun)
+        case _ => false
+      }
+    }
+  }
+
+  /** Collects all args (and possibly the function) as synthetic vals and replaces them in the tree by the reference to
+   *  the lifted its val.
+   */
+  private def transformApplication(tree: Tree, mkTree: (Tree, List[ValDef]) => Tree)(implicit ctx: Context): Tree = tree match {
+    case tree: Apply =>
+      def mkNewApply(newFun: Tree, accSynthVals: List[ValDef]) = {
+        val (synthVals, synthValRefs) = tree.args.map(mkSynthVal).unzip
+        mkTree(cpy.Apply(tree)(newFun, synthValRefs), accSynthVals ::: synthVals)
+      }
+      transformApplication(tree.fun, mkNewApply)
+    case tree: TypeApply =>
+      def mkNewTypeApply(newFun: Tree, accSynthVals: List[ValDef]) =
+        mkTree(cpy.TypeApply(tree)(newFun, tree.args), accSynthVals)
+      transformApplication(tree.fun, mkNewTypeApply)
+    case tree: Select if !tree.qualifier.isInstanceOf[New] =>
+      val (accSynthVal, synthValRef) = mkSynthVal(tree.qualifier)
+      mkTree(Select(synthValRef, tree.name), List(accSynthVal))
+    case _ => mkTree(tree, Nil)
+  }
+
+  /** Makes a synthetic val with the tree and creates a reference to it.
+   *    `tree` --> (`val ev$x = tree`, `ev$x`)
+   */
+  private def mkSynthVal(tree: Tree)(implicit ctx: Context): (ValDef, Tree) = {
+    val synthVal = SyntheticValDef(TempResultName.fresh(), tree)
+    (synthVal, ref(synthVal.symbol))
+  }
+}

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

@@ -44,7 +44,7 @@ class VCInlineMethods extends MiniPhaseTransform with IdentityDenotTransformer {
   override def phaseName: String = "vcInlineMethods"
 
   override def runsAfter: Set[Class[_ <: Phase]] =
-    Set(classOf[ExtensionMethods], classOf[PatternMatcher])
+    Set(classOf[ExtensionMethods], classOf[PatternMatcher], classOf[PhantomArgumentEval])
 
   /** Replace a value class method call by a call to the corresponding extension method.
    *

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -153,6 +153,7 @@ class CompilationTests extends ParallelTesting {
     compileFile("../tests/neg/customArgs/overloadsOnAbstractTypes.scala", allowDoubleBindings) +
     compileFile("../tests/neg/customArgs/xfatalWarnings.scala", defaultOptions.and("-Xfatal-warnings")) +
     compileFile("../tests/neg/customArgs/phantom-overload.scala", allowDoubleBindings) +
+    compileFile("../tests/neg/customArgs/phantom-overload-2.scala", allowDoubleBindings) +
     compileFile("../tests/neg/tailcall/t1672b.scala", defaultOptions) +
     compileFile("../tests/neg/tailcall/t3275.scala", defaultOptions) +
     compileFile("../tests/neg/tailcall/t6574.scala", defaultOptions) +

tests/neg/customArgs/phantom-overload-2.scala

@@ -0,0 +1,21 @@
+
+class phantomOverload2 {
+  import Boo._
+
+  def foo1() = ???
+  def foo1(x: A) = ??? // error
+  def foo1(x1: B)(x2: N) = ??? // error
+
+  def foo2(x1: Int, x2: A) = ???
+  def foo2(x1: A)(x2: Int) = ??? // error
+  def foo2(x1: N)(x2: A)(x3: Int) = ??? // error
+
+  def foo3(x1: Int, x2: A) = ???
+  def foo3(x1: Int, x2: A)(x3: A) = ??? // error
+}
+
+object Boo extends Phantom {
+  type A <: this.Any
+  type B <: this.Any
+  type N = this.Nothing
+}

tests/pos/phantom-in-value-class.scala

@@ -0,0 +1,16 @@
+
+object PhantomInValueClass {
+  import BooUtil._
+  new VC("ghi").foo(boo)
+}
+
+object BooUtil extends Phantom {
+
+  type Boo <: this.Any
+  def boo: Boo = assume
+
+  class VC[T](val x: T) extends AnyVal {
+    def foo(b: Boo) = println(x)
+  }
+
+}

tests/run/phantom-erased-methods.check

@@ -0,0 +1,33 @@
+import scala.runtime.BoxedUnit
+
+/* 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 = {
+    val foo = new Foo
+
+    // check that parameters have been removed from the functions
+    // (would fail with NoSuchMethodException if not erased)
+    foo.getClass.getDeclaredMethod("fun1")
+    foo.getClass.getDeclaredMethod("fun2", classOf[String])
+
+    assert(foo.getClass.getDeclaredMethod("fun3").getReturnType == classOf[BoxedUnit])
+  }
+}
+
+class Foo {
+  import Boo._
+  def fun1(b: BooAny): Unit = ()
+  def fun2(b: BooAny, s: String): Unit = ()
+  def fun3(): BooAny = boo
+}
+
+object Boo extends Phantom {
+  type BooAny = Boo.Any
+  def boo: BooAny = assume
+}

tests/run/phantom-erased-methods.scala

@@ -0,0 +1,26 @@
+x1
+x2
+x3
+x4
+x5
+fun
+y1
+y2
+y3
+y4
+y5
+Fun
+Fun2
+z1
+z2
+z3
+z4
+z5
+Fun2fun
+Fun2
+w1
+w2
+w3
+w4
+w5
+Fun2fun2

tests/run/phantom-methods-11.check

@@ -0,0 +1,74 @@
+/* Run this test with
+ *   `run tests/run/xyz.scala -Xprint-diff-del -Xprint:arrayConstructors,phantomRefErasure,phantomErasure,erasure`
+ * to see the the diffs after PhantomRefErasure, PhantomDeclErasure and Erasure.
+ */
+
+object Test {
+  import Boo._
+
+  def main(args: Array[String]): Unit = {
+    fun(
+      { println("x1"); boo },
+      { println("x2"); boo }
+    )(
+      { println("x3"); boo }
+    )(
+      { println("x4"); boo },
+      { println("x5"); boo }
+    )
+
+    new Fun(
+      { println("y1"); boo },
+      { println("y2"); boo }
+    )(
+      { println("y3"); boo }
+    )(
+      { println("y4"); boo },
+      { println("y5"); boo }
+    )
+
+    (new Fun2().fun)(
+      { println("z1"); boo },
+      { println("z2"); boo }
+    )(
+      { println("z3"); boo }
+    )(
+      { println("z4"); boo },
+      { println("z5"); boo }
+    )
+
+    (new Fun2().fun2)(
+      { println("w1"); boo },
+      { println("w2"); boo }
+    )(
+      { println("w3"); boo }
+    )(
+      { println("w4"); boo },
+      { println("w5"); boo }
+    )
+  }
+
+  def fun(x1: Inky, x2: Inky)(x3: Inky)(x4: Inky, x5: Inky) = {
+    println("fun")
+  }
+
+  class Fun(y1: Inky, y2: Inky)(y3: Inky)(y4: Inky, y5: Inky) {
+    println("Fun")
+  }
+
+  class Fun2 {
+    println("Fun2")
+    def fun(z1: Inky, z2: Inky)(z3: Inky)(z4: Inky, z5: Inky) = {
+      println("Fun2fun")
+    }
+
+    def fun2[T](z1: Inky, z2: Inky)(z3: Inky)(z4: Inky, z5: Inky) = {
+      println("Fun2fun2")
+    }
+  }
+}
+
+object Boo extends Phantom {
+  type Inky <: this.Any
+  def boo: Inky = assume
+}