Erase arguments of phantom type.

nicolasstucki · nicolasstucki · commit 8436d5258165 · 2017-03-22T13:53:55.000+01:00
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.
diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -74,7 +74,9 @@ 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.
       List(new ElimErasedValueType, // Expand erased value types to their underlying implmementation types
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -13,6 +13,7 @@ import config.Printers.config
 import scala.collection.mutable.{ListBuffer, ArrayBuffer}
 import dotty.tools.dotc.transform.TreeTransforms.{TreeTransformer, MiniPhase, TreeTransform}
 import dotty.tools.dotc.transform._
+import dotty.tools.dotc.transform.phantom._
 import Periods._
 import typer.{FrontEnd, RefChecks}
 import ast.tpd
@@ -309,6 +310,7 @@ object Phases {
 
     private var myPeriod: Period = Periods.InvalidPeriod
     private var myBase: ContextBase = null
+    private var myErasedPhantomTerms = false
     private var myErasedTypes = false
     private var myFlatClasses = false
     private var myRefChecked = false
@@ -326,6 +328,7 @@ object Phases {
     def start = myPeriod.firstPhaseId
     def end = myPeriod.lastPhaseId
 
+    final def erasedPhantomTerms = myErasedPhantomTerms // Phase is after phantom terms
     final def erasedTypes = myErasedTypes   // Phase is after erasure
     final def flatClasses = myFlatClasses   // Phase is after flatten
     final def refChecked = myRefChecked     // Phase is after RefChecks
@@ -337,6 +340,7 @@ object Phases {
         assert(myPeriod == Periods.InvalidPeriod, s"phase $this has already been used once; cannot be reused")
       myBase = base
       myPeriod = Period(NoRunId, start, end)
+      myErasedPhantomTerms = prev.getClass == classOf[PhantomTermErasure] || prev.erasedPhantomTerms
       myErasedTypes  = prev.getClass == classOf[Erasure]      || prev.erasedTypes
       myFlatClasses  = prev.getClass == classOf[Flatten]      || prev.flatClasses
       myRefChecked   = prev.getClass == classOf[RefChecks]    || prev.refChecked
diff --git a/compiler/src/dotty/tools/dotc/transform/phantom/PhantomTermErasure.scala b/compiler/src/dotty/tools/dotc/transform/phantom/PhantomTermErasure.scala
@@ -0,0 +1,59 @@
+package dotty.tools.dotc.transform.phantom
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Constants._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.DenotTransformers._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+
+class PhantomTermErasure extends MiniPhaseTransform with InfoTransformer {
+  import tpd._
+
+  override def phaseName: String = "phantomTermErasure"
+
+  /** Check what the phase achieves, to be called at any point after it is finished. */
+  override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
+    def assertNotPhantom(tree: Tree): Unit =
+      assert(!tree.tpe.isPhantom, "All phantom type values should be erased in " + tree)
+    tree match {
+      case Apply(_, args) => args.foreach(assertNotPhantom)
+      case DefDef(_, _, vparamss, tpt, _) => vparamss.foreach(_.foreach(assertNotPhantom))
+      case _ =>
+    }
+  }
+
+  /* Tree transform */
+
+  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree =
+    cpy.Apply(tree)(tree.fun, tree.args.filter(!_.tpe.isPhantom))
+
+  override def transformDefDef(ddef: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree =
+    cpy.DefDef(ddef)(vparamss = ddef.vparamss.map(_.filter(!_.tpt.typeOpt.isPhantom)))
+
+  override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo): Tree =
+    if (tree.symbol.is(Param) && tree.tpe.isPhantom) Literal(Constant(null)).withType(tree.tpe) else tree
+
+  /* Symbol transform */
+
+  def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = erasedPhantomParameters(tp)
+
+  /* private methods */
+
+  private def erasedPhantomParameters(tp: Type)(implicit ctx: Context): Type = tp match {
+    case tp: JavaMethodType => tp
+    case tp: MethodType =>
+      val methodType = if (tp.isImplicit) ImplicitMethodType else MethodType
+      val (erasedParamNames, erasedParamTypes) =
+        tp.paramNames.zip(tp.paramTypes).filterNot(_._2.isPhantom).unzip
+      val erasedReturnType = erasedPhantomParameters(tp.resultType)
+      methodType(erasedParamNames, erasedParamTypes, erasedReturnType)
+    case tp: PolyType =>
+      val erasedReturnType = erasedPhantomParameters(tp.resultType)
+      tp.derivedPolyType(tp.paramNames, tp.paramBounds, erasedReturnType)
+    case _            => tp
+  }
+}
diff --git a/compiler/src/dotty/tools/dotc/transform/phantom/PhantomTermEval.scala b/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))
+
+}
diff --git a/compiler/src/dotty/tools/dotc/transform/phantom/PhantomTypeErasure.scala b/compiler/src/dotty/tools/dotc/transform/phantom/PhantomTypeErasure.scala
@@ -4,6 +4,7 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.DenotTransformers._
+import dotty.tools.dotc.core.Phases._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
@@ -14,6 +15,9 @@ class PhantomTypeErasure extends MiniPhaseTransform with InfoTransformer {
 
   override def phaseName: String = "phantomTypeErasure"
 
+  /** List of names of phases that should precede this phase */
+  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PhantomTermErasure])
+
   /** Check what the phase achieves, to be called at any point after it is finished. */
   override def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = {
     assert(!tree.tpe.isPhantom, tree.tpe + " should be erased in " + tree)
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -318,7 +318,9 @@ trait TypeAssigner {
   def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(implicit ctx: Context) = {
     val ownType = fn.tpe.widen match {
       case fntpe: MethodType =>
-        if (sameLength(fntpe.paramTypes, args) || ctx.phase.prev.relaxedTyping) fntpe.instantiate(args.tpes)
+        def sameLengthAfterPhantomErasure =
+          ctx.phase.erasedPhantomTerms && sameLength(fntpe.paramTypes, args.filterNot(arg => arg.typeOpt.isPhantom))
+        if (sameLength(fntpe.paramTypes, args) || ctx.phase.prev.relaxedTyping|| sameLengthAfterPhantomErasure) fntpe.instantiate(args.tpes)
         else
           errorType(i"wrong number of arguments for $fntpe: ${fn.tpe}, expected: ${fntpe.paramTypes.length}, found: ${args.length}", tree.pos)
       case t =>
