Erase arguments of phantom type.

Author: nicolasstucki

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

@@ -75,6 +75,7 @@ class Compiler {
            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.
+      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

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

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
+  }
+}

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)

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -316,7 +316,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(_, ptypes) =>
-        if (sameLength(ptypes, args) || ctx.phase.prev.relaxedTyping) fntpe.instantiate(args.tpes)
+        def sameLengthAfterPhantomErasure =
+          ctx.phase.erasedPhantomTerms && sameLength(ptypes, args.filterNot(arg => arg.typeOpt.isPhantom))
+        if (sameLength(ptypes, args) || ctx.phase.prev.relaxedTyping || sameLengthAfterPhantomErasure) fntpe.instantiate(args.tpes)
         else
           errorType(i"wrong number of arguments for $fntpe: ${fn.tpe}, expected: ${ptypes.length}, found: ${args.length}", tree.pos)
       case t =>