WIP: split phantom erasure into reference and declaration erasure.

Author: nicolasstucki

src/dotty/tools/dotc/Compiler.scala

@@ -72,7 +72,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 ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
-      List(new PhantomErasure),     // Rewrite trees erasing all values of phantom types.
+      List(new PhantomRefErasure),  // Rewrite trees erasing all value references of phantom types.
+      List(new PhantomDeclErasure),     // Rewrite trees erasing all phantom types declarations.
       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
            new VCElideAllocations,  // Peep-hole optimization to eliminate unnecessary value class allocations

src/dotty/tools/dotc/core/Phases.scala

@@ -302,7 +302,7 @@ object Phases {
 
     private var myPeriod: Period = Periods.InvalidPeriod
     private var myBase: ContextBase = null
-    private var myErasedPhantoms = false
+    private var myErasedRefPhantoms = false
     private var myErasedTypes = false
     private var myFlatClasses = false
     private var myRefChecked = false
@@ -320,7 +320,7 @@ object Phases {
     def start = myPeriod.firstPhaseId
     def end = myPeriod.lastPhaseId
 
-    final def erasedPhantoms = myErasedPhantoms // Phase is after phantom erasure
+    final def erasedRefPhantoms = myErasedRefPhantoms // Phase is after phantom reference erasure
     final def erasedTypes = myErasedTypes   // Phase is after erasure
     final def flatClasses = myFlatClasses   // Phase is after flatten
     final def refChecked = myRefChecked     // Phase is after RefChecks
@@ -332,7 +332,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)
-      myErasedPhantoms = prev.getClass == classOf[PhantomErasure] || prev.erasedPhantoms
+      myErasedRefPhantoms = prev.getClass == classOf[PhantomRefErasure] || prev.erasedRefPhantoms
       myErasedTypes  = prev.getClass == classOf[Erasure]      || prev.erasedTypes
       myFlatClasses  = prev.getClass == classOf[Flatten]      || prev.flatClasses
       myRefChecked   = prev.getClass == classOf[RefChecks]    || prev.refChecked

src/dotty/tools/dotc/transform/Erasure.scala

@@ -32,7 +32,7 @@ class Erasure extends Phase with DenotTransformer { thisTransformer =>
   override def phaseName: String = "erasure"
 
   /** List of names of phases that should precede this phase */
-  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PhantomErasure], classOf[InterceptedMethods], classOf[Splitter], classOf[ElimRepeated])
+  override def runsAfter: Set[Class[_ <: Phase]] = Set(classOf[PhantomDeclErasure], classOf[InterceptedMethods], classOf[Splitter], classOf[ElimRepeated])
 
   def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {
     case ref: SymDenotation =>

src/dotty/tools/dotc/transform/PhantomDeclErasure.scala

@@ -0,0 +1,88 @@
+package dotty.tools.dotc
+package transform
+
+import core.Phases._
+import core.DenotTransformers._
+import core.Symbols._
+import core.Contexts._
+import core.Types._
+import core.Decorators._
+import dotty.tools.dotc.ast.{Trees, tpd}
+import ast.Trees._
+
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
+
+import scala.annotation.tailrec
+
+class PhantomDeclErasure extends MiniPhaseTransform with InfoTransformer {
+  thisTransformer =>
+
+  import dotty.tools.dotc.ast.tpd._
+
+  override def phaseName: String = "phantomDeclErasure"
+
+  /** List of names of phases that should precede this phase */
+  override def runsAfter: Set[Class[_ <: Phase]] =
+    Set(classOf[PhantomRefErasure])
+
+  /** 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 = {
+    def assertNotPhantom(tpe: Type): Unit =
+      assert(!tpe.derivesFrom(defn.PhantomAnyClass), "All phantom type values should be erased in " + tree)
+
+    tree match {
+      case _: TypeTree             =>
+      case _: Trees.TypeDef[_]     =>
+      case tree: TypeDef           => tree.symbol.asClass.classInfo.decls // TODO check decls
+      case ValDef(_, tpt, _)       => assertNotPhantom(tpt.typeOpt)
+      case DefDef(_, _, _, tpt, _) => assertNotPhantom(tpt.typeOpt)
+      case _                       =>
+    }
+    super.checkPostCondition(tree)
+  }
+
+  // Transform trees
+
+  override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context, info: TransformerInfo): List[tpd.Tree] = {
+    val newTrees = trees.filter {
+      case ValDef(_, tpt, _) =>
+        !tpt.tpe.derivesFrom(defn.PhantomAnyClass)
+
+      case tree @ DefDef(_, _, _, tpt, _) =>
+        val isPhantom = tpt.tpe.derivesFrom(defn.PhantomAnyClass)
+        if (isPhantom && tree.symbol.flags.is(Flags.Accessor)) {
+          if (tree.symbol.flags.is(Flags.Mutable))
+            ctx.error("Can not define var with phantom type.", tree.pos)
+          else if (tree.symbol.flags.is(Flags.Lazy))
+            ctx.error("Can not define lazy var with phantom type.", tree.pos)
+        }
+        !isPhantom
+
+      case _ =>
+        true
+    }
+    super.transformStats(newTrees)
+  }
+
+  // Transform symbols
+
+  def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = erasedPhantoms(tp)
+
+  private def erasedPhantoms(tp: Type)(implicit ctx: Context): Type = {
+    val flags = tp.typeSymbol.flags
+    tp match {
+      case tp: ClassInfo if !flags.is(Flags.Package) =>
+        val newDecls = tp.decls.filteredScope(sym => !isPhantomMethodType(sym.info))
+        ClassInfo(tp.prefix, tp.cls, tp.classParents, newDecls, tp.selfInfo)
+
+      case _ => tp
+    }
+  }
+
+  @tailrec private def isPhantomMethodType(tpe: Type)(implicit ctx: Context): Boolean = tpe match {
+    case tpe: MethodicType => tpe.resultType.derivesFrom(defn.PhantomAnyClass) || isPhantomMethodType(tpe.resultType)
+    case _                 => false
+  }
+}

src/dotty/tools/dotc/transform/PhantomErasure.scala renamed to src/dotty/tools/dotc/transform/PhantomRefErasure.scala

@@ -15,12 +15,12 @@ import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, Transforme
 
 import scala.annotation.tailrec
 
-class PhantomErasure extends MiniPhaseTransform with InfoTransformer {
+class PhantomRefErasure extends MiniPhaseTransform with InfoTransformer {
   thisTransformer =>
 
   import dotty.tools.dotc.ast.tpd._
 
-  override def phaseName: String = "phantomErasure"
+  override def phaseName: String = "phantomRefErasure"
 
   /** List of names of phases that should precede this phase */
   override def runsAfter: Set[Class[_ <: Phase]] =
@@ -35,9 +35,6 @@ class PhantomErasure extends MiniPhaseTransform with InfoTransformer {
     tree match {
       case _: TypeTree             =>
       case _: Trees.TypeDef[_]     =>
-      case tree: TypeDef           => tree.symbol.asClass.classInfo.decls // TODO check decls
-      case ValDef(_, tpt, _)       => assertNotPhantom(tpt.typeOpt)
-      case DefDef(_, _, _, tpt, _) => assertNotPhantom(tpt.typeOpt)
       case _                       => assertNotPhantom(tree.tpe)
     }
     super.checkPostCondition(tree)
@@ -46,34 +43,16 @@ class PhantomErasure extends MiniPhaseTransform with InfoTransformer {
   // Transform trees
 
   override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context, info: TransformerInfo): List[tpd.Tree] = {
-    val newTrees = trees.filter {
-      case ValDef(_, tpt, _) =>
-        !tpt.tpe.derivesFrom(defn.PhantomAnyClass)
-
-      case tree @ DefDef(_, _, _, tpt, _) =>
-        val isPhantom = tpt.tpe.derivesFrom(defn.PhantomAnyClass)
-        if (isPhantom && tree.symbol.flags.is(Flags.Accessor)) {
-          if (tree.symbol.flags.is(Flags.Mutable))
-            ctx.error("Can not define var with phantom type.", tree.pos)
-          else if (tree.symbol.flags.is(Flags.Lazy))
-            ctx.error("Can not define lazy var with phantom type.", tree.pos)
-        }
-        !isPhantom
-
+    trees.foreach {
       case tree @ Apply(fun, _) if tree.tpe.derivesFrom(defn.PhantomAnyClass) =>
         ctx.error(s"Functions returning a phantom type can not be in statement position.", fun.pos)
-        false
       case tree @ TypeApply(fun, _) if tree.tpe.derivesFrom(defn.PhantomAnyClass) =>
         ctx.error(s"Functions returning a phantom type can not be in statement position.", fun.pos)
-        false
       case tree: Select if tree.tpe.derivesFrom(defn.PhantomAnyClass) =>
         ctx.error(s"Fields containing a phantom type can not be accessed in statement position.", tree.pos)
-        false
-
       case _ =>
-        true
     }
-    super.transformStats(newTrees)
+    super.transformStats(trees)
   }
 
   override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = {
@@ -117,21 +96,11 @@ class PhantomErasure extends MiniPhaseTransform with InfoTransformer {
 
   def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = erasedPhantoms(tp)
 
-  private def erasedPhantoms(tp: Type)(implicit ctx: Context): Type = {
-    val flags = tp.typeSymbol.flags
-    tp match {
-      case tp: ClassInfo if !flags.is(Flags.Package) =>
-        val newDecls = tp.decls.filteredScope(sym => !isPhantomMethodType(sym.info))
-        ClassInfo(tp.prefix, tp.cls, tp.classParents, newDecls, tp.selfInfo)
-
-      case tp: JavaMethodType => tp
-      case tp: MethodType => erasedMethodPhantoms(tp)
-
-      case tp: PolyType =>
-        PolyType(tp.paramNames)(_ => tp.paramBounds, _ => erasedPhantoms(tp.resType))
-
-      case _ => tp
-    }
+  private def erasedPhantoms(tp: Type)(implicit ctx: Context): Type = tp match {
+    case tp: JavaMethodType => tp
+    case tp: MethodType     => erasedMethodPhantoms(tp)
+    case tp: PolyType       => PolyType(tp.paramNames)(_ => tp.paramBounds, _ => erasedPhantoms(tp.resType))
+    case _                  => tp
   }
 
   private def erasedMethodPhantoms(tp: MethodType)(implicit ctx: Context): MethodType = {
@@ -140,15 +109,8 @@ class PhantomErasure extends MiniPhaseTransform with InfoTransformer {
       else (tp.paramNames, tp.paramTypes)
     val erasedResultType = erasedPhantoms(tp.resultType)
     tp match {
-      case _: ImplicitMethodType =>
-        ImplicitMethodType(erasedParamNames, erasedParamTypes, erasedResultType)
-      case _ =>
-        MethodType(erasedParamNames, erasedParamTypes, erasedResultType)
+      case _: ImplicitMethodType => ImplicitMethodType(erasedParamNames, erasedParamTypes, erasedResultType)
+      case _                     => MethodType(erasedParamNames, erasedParamTypes, erasedResultType)
     }
   }
-
-  @tailrec private def isPhantomMethodType(tpe: Type)(implicit ctx: Context): Boolean = tpe match {
-    case tpe: MethodicType => tpe.resultType.derivesFrom(defn.PhantomAnyClass) || isPhantomMethodType(tpe.resultType)
-    case _                 => false
-  }
 }

src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -304,7 +304,7 @@ class TreeChecker extends Phase with SymTransformer {
             mapOver(tp)
             definedBinders -= tp
           case tp: ParamType =>
-            assert(definedBinders.contains(tp.binder) || (tp.derivesFrom(defn.PhantomAnyClass) && ctx.phase.erasedPhantoms), s"orphan param: $tp")
+            assert(definedBinders.contains(tp.binder) || (tp.derivesFrom(defn.PhantomAnyClass) && ctx.phase.erasedRefPhantoms), s"orphan param: $tp")
           case tp: TypeVar =>
             apply(tp.underlying)
           case _ =>

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

@@ -304,7 +304,7 @@ trait TypeAssigner {
     val ownType = fn.tpe.widen match {
       case fntpe @ MethodType(_, ptypes) =>
         if (sameLength(ptypes, args) || ctx.phase.prev.relaxedTyping ||
-            (ctx.phase.erasedPhantoms && sameLength(ptypes, args.filterNot(_.typeOpt.derivesFrom(defn.PhantomAnyClass))))) {
+            (ctx.phase.erasedRefPhantoms && sameLength(ptypes, args.filterNot(_.typeOpt.derivesFrom(defn.PhantomAnyClass))))) {
           fntpe.instantiate(args.tpes)
         } else {
           errorType(i"wrong number of parameters for ${fn.tpe}; expected: ${ptypes.length}", tree.pos)