Remove PhantomTypeErasure and integrate into Erasure.

Author: nicolasstucki

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

@@ -11,7 +11,6 @@ import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
 import reporting.{Reporter, ConsoleReporter}
 import Phases.Phase
 import transform._
-import transform.phantom._
 import util.FreshNameCreator
 import transform.TreeTransforms.{TreeTransform, TreeTransformer}
 import core.DenotTransformers.DenotTransformer
@@ -75,7 +74,6 @@ 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 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
            new VCElideAllocations,  // Peep-hole optimization to eliminate unnecessary value class allocations

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

@@ -988,8 +988,6 @@ class Definitions {
     sym.name == nme.assume_ && (sym.owner eq PhantomClass)
 
   lazy val ErasedPhantomClass = ctx.requiredClass("dotty.runtime.ErasedPhantom")
-  def ErasedPhantomType = ErasedPhantomClass.typeRef
+  def ErasedPhantomType(implicit ctx: Context) = ErasedPhantomClass.typeRef
 
-  lazy val ErasedPhantomLatticeClass = ctx.requiredClass("dotty.runtime.ErasedPhantomLattice")
-  def ErasedPhantomLatticeType = ErasedPhantomLatticeClass.typeRef
 }

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

@@ -364,6 +364,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       else if (semiEraseVCs && isDerivedValueClass(sym)) eraseDerivedValueClassRef(tp)
       else if (sym == defn.ArrayClass) apply(tp.appliedTo(TypeBounds.empty)) // i966 shows that we can hit a raw Array type.
       else if (defn.isSyntheticFunctionClass(sym)) defn.erasedFunctionType(sym)
+      else if (defn.isPhantomAnyClass(tp.symbol) || defn.isPhantomNothingClass(tp.symbol)) defn.ErasedPhantomType
       else eraseNormalClassRef(tp)
     case tp: RefinedType =>
       val parent = tp.parent
@@ -400,8 +401,8 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           else classParents.mapConserve(eraseTypeRef) match {
             case tr :: trs1 =>
               assert(!tr.classSymbol.is(Trait), cls)
-              val tr1 = if (cls is Trait) defn.ObjectType else tr
-              tr1 :: trs1.filterNot(_ isRef defn.ObjectClass)
+              val tr1 = if (cls.is(Trait) || (tr.symbol eq defn.PhantomClass)) defn.ObjectType else tr
+              tr1 :: trs1.filterNot(x => x.isRef(defn.ObjectClass) || x.isRef(defn.PhantomClass))
             case nil => nil
           }
         val erasedDecls = decls.filteredScope(sym => !sym.isType || sym.isClass)
@@ -504,6 +505,8 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         }
         if (defn.isSyntheticFunctionClass(sym))
           sigName(defn.erasedFunctionType(sym))
+        else if (defn.isPhantomAnyClass(tp.symbol) || defn.isPhantomNothingClass(tp.symbol))
+          sigName(defn.ErasedPhantomType)
         else
           normalizeClass(sym.asClass).fullName.asTypeName
       case defn.ArrayOf(elem) =>

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

@@ -434,7 +434,8 @@ object Erasure extends TypeTestsCasts{
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context) = {
       val ntree = interceptTypeApply(tree.asInstanceOf[TypeApply])(ctx.withPhase(ctx.erasurePhase))
 
-      ntree match {
+      if (defn.isPhantomAssume(tree.fun.symbol)) Literal(Constant(null)).withType(defn.ErasedPhantomType)
+      else ntree match {
         case TypeApply(fun, args) =>
           val fun1 = typedExpr(fun, WildcardType)
           fun1.tpe.widen match {

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

@@ -2,18 +2,18 @@
 class phantomOverload {
   import Boo._
   import Boo2._
+/* TODO
+  def foo1(): A = nothing
+  def foo1(): B = nothing
+  def foo1(): C = nothing
+  def foo1(): N = nothing
 
-  def foo1(): A = nothing // error
-  def foo1(): B = nothing // error
-  def foo1(): C = nothing // error
-  def foo1(): N = nothing // error
-
-  def foo2(x: A) = ??? // error
-  def foo2(x: A) = ??? // error
-  def foo2(x: B) = ??? // error
-  def foo2(x: C) = ??? // error
-  def foo2(x: N) = ??? // error
-
+  def foo2(x: A) = ???
+  def foo2(x: A) = ???
+  def foo2(x: B) = ???
+  def foo2(x: C) = ???
+  def foo2(x: N) = ???
+*/
 }
 
 object Boo extends Phantom {