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

@@ -69,7 +69,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 ErasedPhantom. 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: ErasedPhantom = 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 ErasedPhantom. Where fields
  *    with ErasedPhantom type are not memoized (see transform/Memoize.scala).
  *  - Calls to Phantom.assume become calls to ErasedPhantom.UNIT. Intended to be optimized away by local optimizations.
@@ -21,4 +24,7 @@ object PhantomErasure {
   /** Returns the default erased tree for a call to Phantom.assume */
   def erasedAssume(implicit ctx: Context): Tree = ref(defn.ErasedPhantom_UNIT)
 
+  /** Returns the default erased tree for a phantom parameter ref */
+  def erasedParameterRef(implicit ctx: Context): Tree = ref(defn.ErasedPhantom_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

@@ -400,12 +400,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

@@ -208,6 +208,8 @@ object Erasure extends TypeTestsCasts{
           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))
@@ -417,6 +419,7 @@ object Erasure extends TypeTestsCasts{
 
     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 =
@@ -474,7 +477,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}")
@@ -535,6 +538,11 @@ object Erasure extends TypeTestsCasts{
         vparamss1 = (tpd.ValDef(bunchedParam) :: Nil) :: Nil
         rhs1 = untpd.Block(paramDefs, rhs1)
       }
+      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,
@@ -618,4 +626,7 @@ 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.widenDealias.classSymbol eq defn.ErasedPhantomClass
 }

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

@@ -154,6 +154,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 dotty.runtime.ErasedPhantom
+
+/* 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[ErasedPhantom])
+  }
+}
+
+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