Make all phantoms unused

Author: nicolasstucki

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

@@ -1088,21 +1088,15 @@ class Definitions {
 
     val any = enterCompleteClassSymbol(cls, tpnme.Any, Protected | Final | NoInitsTrait, Nil)
     val nothing = enterCompleteClassSymbol(cls, tpnme.Nothing, Protected | Final | NoInitsTrait, List(any.typeRef))
-    enterMethod(cls, nme.assume_, ExprType(nothing.typeRef), Protected | Final | Method)
+    enterMethod(cls, nme.assume_, ExprType(nothing.typeRef), Protected | Final | Method | Unused)
 
     cls
   }
   lazy val Phantom_AnyClass = PhantomClass.unforcedDecls.find(_.name eq tpnme.Any).asClass
   lazy val Phantom_NothingClass = PhantomClass.unforcedDecls.find(_.name eq tpnme.Nothing).asClass
-  lazy val Phantom_assume = PhantomClass.unforcedDecls.find(_.name eq nme.assume_)
 
   /** If the symbol is of the class scala.Phantom.Any or scala.Phantom.Nothing */
   def isPhantomTerminalClass(sym: Symbol) = (sym eq Phantom_AnyClass) || (sym eq Phantom_NothingClass)
 
-
   lazy val ErasedPhantomType: TypeRef = ctx.requiredClassRef("dotty.runtime.ErasedPhantom")
-  def ErasedPhantomClass(implicit ctx: Context) = ErasedPhantomType.symbol.asClass
-
-  def ErasedPhantom_UNIT(implicit ctx: Context) = ErasedPhantomClass.linkedClass.requiredValue("UNIT")
-
 }

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

@@ -84,7 +84,7 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
    *  to the parameter part of this signature.
    */
   def prepend(params: List[Type], isJava: Boolean)(implicit ctx: Context) =
-    Signature(params.collect { case p if !p.isPhantom => sigName(p, isJava) } ++ paramsSig, resSig)
+    Signature(params.map(p => sigName(p, isJava)) ++ paramsSig, resSig)
 
   /** A signature is under-defined if its paramsSig part contains at least one
    *  `tpnme.Uninstantiated`. Under-defined signatures arise when taking a signature

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

@@ -378,7 +378,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.isPhantomTerminalClass(sym)) PhantomErasure.erasedPhantomType
+      else if (defn.isPhantomTerminalClass(sym)) defn.ErasedPhantomType
       else if (sym eq defn.PhantomClass) defn.ObjectType // To erase the definitions of Phantom.{assume, Any, Nothing}
       else eraseNormalClassRef(tp)
     case tp: AppliedType =>
@@ -399,10 +399,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
         erasureFn(tp.isJavaMethod, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
-      val (names, formals0) =
-        if (tp.isUnusedMethod) (Nil, Nil)
-        else if (tp.paramInfos.exists(_.isPhantom)) tp.paramNames.zip(tp.paramInfos).filterNot(_._2.isPhantom).unzip
-        else (tp.paramNames, tp.paramInfos)
+      val (names, formals0) = if (tp.isUnusedMethod) (Nil, Nil) else (tp.paramNames, tp.paramInfos)
       val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>
@@ -520,8 +517,6 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         }
         if (defn.isSyntheticFunctionClass(sym))
           sigName(defn.erasedFunctionType(sym))
-        else if (defn.isPhantomTerminalClass(tp.symbol))
-          sigName(PhantomErasure.erasedPhantomType)
         else
           normalizeClass(sym.asClass).fullName.asTypeName
       case tp: AppliedType =>

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

@@ -129,7 +129,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
     // Produce aligned accessors and constructor parameters. We have to adjust
     // for any outer parameters, which are last in the sequence of original
     // parameter accessors but come first in the constructor parameter list.
-    val accessors = cls.paramAccessors.filterNot(x => x.isSetter || x.info.resultType.classSymbol == defn.ErasedPhantomClass)
+    val accessors = cls.paramAccessors.filterNot(x => x.isSetter)
     val vparamsWithOuterLast = vparams match {
       case vparam :: rest if vparam.name == nme.OUTER => rest ::: vparam :: Nil
       case _ => vparams

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

@@ -28,7 +28,6 @@ import ValueClasses._
 import TypeUtils._
 import ExplicitOuter._
 import core.Mode
-import core.PhantomErasure
 import reporting.trace
 
 class Erasure extends Phase with DenotTransformer {
@@ -210,8 +209,6 @@ object Erasure {
           val tree1 =
             if (tree.tpe isRef defn.NullClass)
               adaptToType(tree, underlying)
-            else if (wasPhantom(underlying))
-              PhantomErasure.erasedParameterRef
             else if (!(tree.tpe <:< tycon)) {
               assert(!(tree.tpe.typeSymbol.isPrimitiveValueClass))
               val nullTree = Literal(Constant(null))
@@ -427,16 +424,9 @@ object Erasure {
         }
       }
 
-      if ((origSym eq defn.Phantom_assume) || (origSym.is(Flags.ParamAccessor) && wasPhantom(pt)))
-        PhantomErasure.erasedAssume
-      else recur(typed(tree.qualifier, AnySelectionProto))
+      recur(typed(tree.qualifier, AnySelectionProto))
     }
 
-    override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context): tpd.Tree =
-      if (tree.symbol eq defn.Phantom_assume) PhantomErasure.erasedAssume
-      else if (tree.symbol.is(Flags.Param) && wasPhantom(tree.typeOpt)) PhantomErasure.erasedParameterRef
-      else super.typedIdent(tree, pt)
-
     override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree =
       if (tree.symbol == ctx.owner.lexicallyEnclosingClass || tree.symbol.isStaticOwner) promote(tree)
       else {
@@ -496,11 +486,9 @@ object Erasure {
                   .withType(defn.ArrayOf(defn.ObjectType))
                 args0 = bunchedArgs :: Nil
               }
-              // Arguments are phantom if an only if the parameters are phantom, guaranteed by the separation of type lattices
-              val args1 = args0.filterConserve(arg => !wasPhantom(arg.typeOpt))
-              assert(args1 hasSameLengthAs mt.paramInfos)
-              val args2 = args1.zipWithConserve(mt.paramInfos)(typedExpr)
-              untpd.cpy.Apply(tree)(fun1, args2) withType mt.resultType
+              assert(args0 hasSameLengthAs mt.paramInfos)
+              val args1 = args0.zipWithConserve(mt.paramInfos)(typedExpr)
+              untpd.cpy.Apply(tree)(fun1, args1) withType mt.resultType
             case _ =>
               throw new MatchError(i"tree $tree has unexpected type of function ${fun1.tpe.widen}, was ${fun.typeOpt.widen}")
           }
@@ -561,11 +549,6 @@ object Erasure {
         rhs1 = untpd.Block(paramDefs, rhs1)
       }
       vparamss1 = vparamss1.mapConserve(_.filterConserve(!_.symbol.is(Flags.Unused)))
-      vparamss1 = vparamss1.mapConserve(_.filterConserve(vparam => !wasPhantom(vparam.tpe)))
-      if (sym.is(Flags.ParamAccessor) && wasPhantom(ddef.tpt.tpe)) {
-        sym.resetFlag(Flags.ParamAccessor)
-        rhs1 = PhantomErasure.erasedParameterRef
-      }
       val ddef1 = untpd.cpy.DefDef(ddef)(
         tparams = Nil,
         vparamss = vparamss1,
@@ -680,7 +663,4 @@ object Erasure {
 
   def takesBridges(sym: Symbol)(implicit ctx: Context) =
     sym.isClass && !sym.is(Flags.Trait | Flags.Package)
-
-  private def wasPhantom(tp: Type)(implicit ctx: Context): Boolean =
-    tp.widenDealias.classSymbol eq defn.ErasedPhantomClass
 }

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

@@ -174,14 +174,6 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
     } else ddef
   }
 
-  override def transformValDef(vdef: tpd.ValDef)(implicit ctx: Context): tpd.Tree = {
-    if (vdef.tpt.tpe.isPhantom) {
-      if (vdef.symbol.is(Mutable)) ctx.error("var fields cannot have Phantom types", vdef.pos)
-      else if (vdef.symbol.hasAnnotation(defn.VolatileAnnot)) ctx.error("Phantom fields cannot be @volatile", vdef.pos)
-    }
-    vdef
-  }
-
   override def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
     ast.Trees.flatten(reorderAndComplete(trees)(ctx.withPhase(thisPhase.next)))
 

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

@@ -240,7 +240,7 @@ object GenericSignatures {
 
         case mtpe: MethodType =>
           // unused method parameters do not make it to the bytecode.
-          val params = if (mtpe.isUnusedMethod) Nil else mtpe.paramInfos.filterNot(_.isPhantom)
+          val params = if (mtpe.isUnusedMethod) Nil else mtpe.paramInfos
           val restpe = mtpe.resultType
           builder.append('(')
           // TODO: Update once we support varargs

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

@@ -107,7 +107,6 @@ import Decorators._
       if (sym eq defn.NothingClass) Throw(Literal(Constant(null)))
       else if (sym eq defn.NullClass) Literal(Constant(null))
       else if (sym eq defn.BoxedUnitClass) ref(defn.BoxedUnit_UNIT)
-      else if (sym eq defn.ErasedPhantomClass) ref(defn.ErasedPhantom_UNIT)
       else {
         assert(false, sym + " has no erased bottom tree")
         EmptyTree
@@ -120,11 +119,8 @@ import Decorators._
       def adaptToField(tree: Tree): Tree =
         if (tree.isEmpty) tree else tree.ensureConforms(field.info.widen)
 
-      def isErasableBottomField(cls: Symbol): Boolean = {
-        // TODO: For Scala.js, return false if this field is in a js.Object unless it is an ErasedPhantomClass.
-        !field.isVolatile &&
-        ((cls eq defn.NothingClass) || (cls eq defn.NullClass) || (cls eq defn.BoxedUnitClass) || (cls eq defn.ErasedPhantomClass))
-      }
+      def isErasableBottomField(cls: Symbol): Boolean =
+        !field.isVolatile && ((cls eq defn.NothingClass) || (cls eq defn.NullClass) || (cls eq defn.BoxedUnitClass))
 
       if (sym.isGetter) {
         var rhs = tree.rhs.changeOwnerAfter(sym, field, thisPhase)

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

@@ -163,7 +163,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
       val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.pos) // x$0
       def wildcardAscription(tp: Type) = Typed(Underscore(tp), TypeTree(tp))
       val pattern = Bind(thatAsClazz, wildcardAscription(clazzType)) // x$0 @ (_: C)
-      val comparisons = accessors collect { case accessor if !accessor.info.isPhantom =>
+      val comparisons = accessors map { accessor =>
         This(clazz).select(accessor).select(defn.Any_==).appliedTo(ref(thatAsClazz).select(accessor)) }
       val rhs = // this.x == this$0.x && this.y == x$0.y
         if (comparisons.isEmpty) Literal(Constant(true)) else comparisons.reduceLeft(_ and _)
@@ -191,7 +191,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
      */
     def valueHashCodeBody(implicit ctx: Context): Tree = {
       assert(accessors.nonEmpty)
-      assert(accessors.tail.forall(a => a.info.isPhantom || a.is(Unused)))
+      assert(accessors.tail.forall(_ is Unused))
       ref(accessors.head).select(nme.hashCode_).ensureApplied
     }
 

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

@@ -1,9 +1,11 @@
 package dotty.tools.dotc.transform
 
 import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 import dotty.tools.dotc.typer.EtaExpansion
 
@@ -36,9 +38,10 @@ class UnusedArgLift extends MiniPhase {
 
   /** Check what the phase achieves, to be called at any point after it is finished. */
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
-    case tree: Apply =>
-      tree.args.foreach { arg =>
-        assert(!arg.tpe.isPhantom || isPureExpr(arg))
+    case tree: Apply if tree.tpe.widen.isUnusedMethod =>
+      tree.args.foreach {
+        case TypeApply(Select(Literal(const), nme.asInstanceOf_),List(tpt: TypeTree)) if const.value == null && tpt.tpe.isPhantom => // OK
+        case arg => assert(isPureExpr(arg), arg)
       }
     case _ =>
   }
@@ -47,29 +50,15 @@ class UnusedArgLift extends MiniPhase {
 
   override def transformApply(tree: Apply)(implicit ctx: Context): Tree = tree.tpe.widen match {
     case _: MethodType => tree // Do the transformation higher in the tree if needed
-    case _ =>
-      if (!hasImpurePhantomArgs(tree) && !hasUnusedParams(tree)) tree
-      else {
-        val buffer = ListBuffer.empty[Tree]
-        val app = EtaExpansion.liftApp(buffer, tree)
-        seq(buffer.result(), app)
-      }
+    case _ if hasUnusedParams(tree) =>
+      val buffer = ListBuffer.empty[Tree]
+      val app = EtaExpansion.liftApp(buffer, tree)
+      seq(buffer.result(), app)
+    case _ => tree
   }
 
   /* private methods */
 
-  /** Returns true if at least on of the arguments is an impure phantom.
-   *  Inner applies are also checked in case of multiple parameter list.
-   */
-  private def hasImpurePhantomArgs(tree: Apply)(implicit ctx: Context): Boolean = {
-    tree.args.exists(arg => arg.tpe.isPhantom && !isPureExpr(arg)) || {
-      tree.fun match {
-        case fun: Apply => hasImpurePhantomArgs(fun)
-        case _ => false
-      }
-    }
-  }
-
   /** Returns true if at least on of the arguments is an unused parameter.
    *  Inner applies are also checked in case of multiple parameter list.
    */

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

@@ -38,13 +38,16 @@ class UnusedChecks extends MiniPhase {
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context): tree.type = {
     checkUnusedNothing(tree)
+    checkPhantomIsUnused(tree)
     checkedValOrDefDefRHS(tree)
+
   }
 
   override def transformValDef(tree: ValDef)(implicit ctx: Context): tree.type = {
     checkUnusedNothing(tree)
     if (tree.symbol.is(Unused) && tree.symbol.is(MutableOrLazy))
       ctx.error(tree.symbol.showKind + " cannot be unused", tree.pos)
+    checkPhantomIsUnused(tree)
     checkedValOrDefDefRHS(tree)
   }
 
@@ -99,4 +102,11 @@ class UnusedChecks extends MiniPhase {
 
   private def isUnusedContext(implicit ctx: Context): Boolean =
     ctx.owner.ownersIterator.exists(_.is(Unused)) // TODO make context mode?
+
+  private def checkPhantomIsUnused(tree: ValOrDefDef)(implicit ctx: Context): Unit = {
+    if (!tree.symbol.is(Unused) && tree.tpt.tpe.finalResultType.isPhantom) {
+      if (tree.symbol.is(Param)) ctx.error("phantom parameters must be `unused`", tree.pos)
+      else ctx.error(tree.symbol.showKind + " must be `unused` to return a phantom", tree.pos)
+    }
+  }
 }

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

@@ -11,7 +11,6 @@ import core.NameOps._
 import transform.MegaPhase.MiniPhase
 import config.Printers.simplify
 import ast.tpd
-import dotty.tools.dotc.core.PhantomErasure
 
 import scala.annotation.tailrec
 
@@ -184,8 +183,6 @@ object Simplify {
                             sym.owner.is(CaseClass)                  &&
                             sym.name.isSelectorName                  &&
                             !sym.info.decls.exists(_.is(Mutable | Lazy)) // Conservatively covers case class A(var x: Int)
-    val isErasedPhantom   = PhantomErasure.isErasedPhantom(sym)
-
-    isImmutableGetter || isCaseAccessor || isProductAccessor || isErasedPhantom
+    isImmutableGetter || isCaseAccessor || isProductAccessor
   }
 }

compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala

@@ -494,12 +494,10 @@ object Checking {
           case param :: params =>
             if (param.is(Mutable))
               ctx.error(ValueClassParameterMayNotBeAVar(clazz, param), param.pos)
-            if (param.info.isPhantom)
-              ctx.error("value class first parameter must not be phantom", param.pos)
-            else if (param.is(Unused))
+            if (param.is(Unused))
               ctx.error("value class first parameter cannot be `unused`", param.pos)
             else {
-              for (p <- params if !(p.info.isPhantom || p.is(Unused)))
+              for (p <- params if !p.is(Unused))
                 ctx.error("value class can only have one non `unused` parameter", p.pos)
             }
           case Nil =>