Add support for non pure methods returning phantoms.

Author: nicolasstucki

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

@@ -74,7 +74,8 @@ class Compiler {
            new AugmentScala2Traits, // Expand traits defined in Scala 2.11 to simulate old-style rewritings
            new ResolveSuper,        // Implement super accessors and add forwarders to trait methods
            new PrimitiveForwarders, // Add forwarders to trait methods that have a mismatch between generic and primitives
-           new ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
+           new ArrayConstructors,   // Intercept creation of (non-generic) arrays and intrinsify.
+           new PhantomTermEval),    // Extracts the evaluation of phantom arguments placing them before the call.
       List(new PhantomTermErasure), // Erases phantom parameters and arguments
       List(new PhantomTypeErasure), // Erases phantom types to ErasedPhantom
       List(new Erasure),            // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.

compiler/src/dotty/tools/dotc/transform/phantom/PhantomTermEval.scala

@@ -0,0 +1,50 @@
+package dotty.tools.dotc.transform.phantom
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+
+class PhantomTermEval extends MiniPhaseTransform {
+  import tpd._
+
+  override def phaseName: String = "phantomTermEval"
+
+  /** Check what the phase achieves, to be called at any point after it is finished. */
+  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
+    // TODO
+  }
+
+  /* Tree transform */
+
+  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = tree.tpe match {
+    case _: MethodType => tree
+    case _ if tree.args.forall(!_.tpe.isPhantom) => tree
+    case _ =>
+      val argsVals = tree.args.map(toSynthVal)
+
+      def evalArgsInBlock() = Block(argsVals, cpy.Apply(tree)(tree.fun, refs(argsVals)))
+      def evalFunAndArgsInBlock(fun: Select) = {
+        val qualVal = toSynthVal(fun.qualifier)
+        val app = cpy.Apply(tree)(Select(ref(qualVal.symbol), fun.name), refs(argsVals))
+        Block(qualVal :: argsVals, app)
+      }
+
+      tree.fun match {
+        case fun: Select =>
+          if (fun.qualifier.isInstanceOf[New]) evalArgsInBlock()
+          else evalFunAndArgsInBlock(fun)
+        case _ => evalArgsInBlock()
+      }
+  }
+
+  /* private methods */
+
+  private def toSynthVal(t: Tree)(implicit ctx: Context) =
+    SyntheticValDef(ctx.freshName("ev$").toTermName, t)
+
+  private def refs(vals: List[Tree])(implicit ctx: Context) =
+    vals.map(x => ref(x.symbol))
+
+}

tests/run/phantom-methods-10.check

@@ -0,0 +1,3 @@
+fun
+inky
+pacFun4

tests/run/phantom-methods-10.scala

@@ -0,0 +1,31 @@
+/* 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 = {
+    fun2.pacFun4(inky)
+  }
+
+  def pacFun4(clyde: Inky) = {
+    println("pacFun4")
+  }
+
+  def inky: Inky = {
+    println("inky")
+    boo[Inky]
+  }
+
+  def fun2 = {
+    println("fun")
+    this
+  }
+}
+
+object Boo extends Phantom {
+  type Inky <: this.Any
+  def boo[B <: this.Any]: B = assume[B]
+}

tests/run/phantom-methods-8.check

@@ -0,0 +1,2 @@
+inky
+pacFun4

tests/run/phantom-methods-8.scala

@@ -0,0 +1,26 @@
+/* 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 = {
+    pacFun4(inky)
+  }
+
+  def pacFun4(clyde: Inky) = {
+    println("pacFun4")
+  }
+
+  def inky: Inky = {
+    println("inky")
+    Boo.boo[Inky]
+  }
+}
+
+object Boo extends Phantom {
+  type Inky <: Boo.Any
+  def boo[B <: Boo.Any]: B = assume[B]
+}

tests/run/phantom-methods-9.check

@@ -0,0 +1,3 @@
+fun
+inky
+pacFun4

tests/run/phantom-methods-9.scala

@@ -0,0 +1,31 @@
+/* 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 = {
+    fun1().pacFun4(inky)
+  }
+
+  def pacFun4(clyde: Inky) = {
+    println("pacFun4")
+  }
+
+  def inky: Inky = {
+    println("inky")
+    boo[Inky]
+  }
+
+  def fun1() = {
+    println("fun")
+    this
+  }
+}
+
+object Boo extends Phantom {
+  type Inky <: Boo.Any
+  def boo[B <: Boo.Any]: B = assume[B]
+}