Use EtaExpansion.liftApp for impure phantom arguments

Author: nicolasstucki

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

@@ -69,7 +69,7 @@ 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 PhantomArgumentEval, // Extracts the evaluation of phantom arguments placing them before the call.
+      List(new PhantomArgLift, // Extracts the evaluation of phantom arguments placing them before the call.
            new VCInlineMethods,     // Inlines calls to value class methods
            new SeqLiterals,         // Express vararg arguments as arrays
            new InterceptedMethods,  // Special handling of `==`, `|=`, `getClass` methods

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

@@ -7,7 +7,7 @@ import dotty.tools.dotc.core.Types.Type
 
 /** Phantom erasure erases:
  *
- *  - Parameters/arguments are removed from the function definition/call in `PhantomArgumentEval`.
+ *  - Parameters/arguments are removed from the function definition/call in `PhantomArgLift`.
  *    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

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

@@ -0,0 +1,79 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.NameKinds._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+import dotty.tools.dotc.typer.EtaExpansion
+
+import scala.collection.mutable.ListBuffer
+
+/** 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 PhantomArgLift extends MiniPhaseTransform {
+  import tpd._
+
+  override def phaseName: String = "phantomArgLift"
+
+  /** 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 || isPureExpr(arg))
+      }
+    case _ =>
+  }
+
+  /* Tree transform */
+
+  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = tree.tpe.widen match {
+    case _: MethodType => tree // Do the transformation higher in the tree if needed
+    case _ =>
+      if (!hasImpurePhantomArgs(tree)) tree
+      else {
+        val buffer = ListBuffer.empty[Tree]
+        val app = EtaExpansion.liftApp(buffer, tree)
+        if (buffer.isEmpty) app
+        else Block(buffer.result(), app)
+      }
+  }
+
+  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 = SyntheticValDef(TempResultName.fresh(), tree.rhs)
+      val synthValRef = ref(synthVal.symbol)
+      Block(List(synthVal), Assign(tree.lhs, synthValRef))
+    }
+  }
+
+  /* private methods */
+
+  /** Returns true if at least on of the arguments is an impure phantom.
+   *  Inner applies are also checked in case of multiple parameter list.
+   */
+  private def hasImpurePhantomArgs(tree: Apply)(implicit ctx: Context): Boolean = {
+    tree.args.exists(arg => arg.tpe.isPhantom && !isPureExpr(arg)) || {
+      tree.fun match {
+        case fun: Apply => hasImpurePhantomArgs(fun)
+        case _ => false
+      }
+    }
+  }
+
+}

compiler/src/dotty/tools/dotc/transform/PhantomArgumentEval.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], classOf[PhantomArgumentEval])
+    Set(classOf[ExtensionMethods], classOf[PatternMatcher], classOf[PhantomArgLift])
 
   /** Replace a value class method call by a call to the corresponding extension method.
    *