Simplify the definition of Phantom.assume.

Author: nicolasstucki

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

@@ -972,10 +972,7 @@ class Definitions {
 
     val any = enterCompleteClassSymbol(cls, tpnme.Any, Protected | Final | NoInitsTrait, Nil)
     val nothing = enterCompleteClassSymbol(cls, tpnme.Nothing, Protected | Final | NoInitsTrait, List(any.typeRef))
-
-    val tparamNames = List("P".toTypeName)
-    val ptype = PolyType(tparamNames)(_ => TypeBounds(nothing.typeRef, any.typeRef) :: Nil, TypeParamRef(_, 0))
-    newSymbol(cls, nme.assume_, Protected | Final | Method, ptype).entered
+    enterMethod(cls, nme.assume_, MethodType(Nil, nothing.typeRef), Protected | Final | Method)
 
     cls
   }

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

@@ -434,14 +434,7 @@ 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))
 
-      if (defn.isPhantomAssume(tree.fun.symbol)) {
-        /* All phantom types are erased to `ErasedPhantom` (an uninstantiable final abstract class),
-         * hence the only valid term for a `ErasedPhantom` is `null`.
-         * As `Phantom.assume[P <: Phantom.Any]` is the only way to instantiate phantoms, all runtime
-         * values of phantom type become `null` (no instantiation overhead).
-         */
-        Literal(Constant(null)).withType(defn.ErasedPhantomType)
-      } else ntree match {
+      ntree match {
         case TypeApply(fun, args) =>
           val fun1 = typedExpr(fun, WildcardType)
           fun1.tpe.widen match {
@@ -461,7 +454,14 @@ object Erasure extends TypeTestsCasts{
       val Apply(fun, args) = tree
       if (fun.symbol == defn.dummyApply)
         typedUnadapted(args.head, pt)
-      else typedExpr(fun, FunProto(args, pt, this)) match {
+      else if (defn.isPhantomAssume(fun.symbol)) {
+        /* All phantom types are erased to `ErasedPhantom` (an un-instantiable final abstract class),
+         * hence the only valid term for a `ErasedPhantom` is `null`.
+         * As `Phantom.assume` is the only way to instantiate phantoms, all runtime values of
+         * phantom type become `null` (no instantiation overhead).
+         */
+        Literal(Constant(null)).withType(defn.ErasedPhantomType)
+      } else typedExpr(fun, FunProto(args, pt, this)) match {
         case fun1: Apply => // arguments passed in prototype were already passed
           fun1
         case fun1 =>

library/src/scala/Phantom.scala

@@ -7,7 +7,7 @@ trait Phantom {
 
   protected final abstract class Nothing extends Any
 
-  protected final def assume[P >: this.Nothing <: this.Any]: P =
-    null.asInstanceOf[P] // This implementation matches the erased implementation
+  protected final def assume: this.Nothing =
+    null.asInstanceOf[this.Nothing] // This implementation matches the erased implementation
 }
 */

tests/neg/customArgs/phantom-overload.scala

@@ -19,10 +19,10 @@ object Boo extends Phantom {
   type A <: this.Any
   type B <: this.Any
   type N = this.Nothing
-  def nothing = assume[this.Nothing]
+  def nothing: this.Nothing = assume
 }
 
 object Boo2 extends Phantom {
   type C <: this.Any
-  def nothing2 = assume[this.Nothing]
+  def nothing2: this.Nothing = assume
 }

tests/neg/phantom-Eq.scala

@@ -26,14 +26,13 @@ object EqUtil extends Phantom {
     def ===[U] (y: U)(implicit ce: PhantomEq[T, U]) = x.equals(y)
   }
 
-  implicit def eqString: PhantomEqEq[String] = assume[PhantomEqEq[String]]
-  implicit def eqInt: PhantomEqEq[Int]       = assume[PhantomEqEq[Int]]
-  implicit def eqDouble: PhantomEqEq[Double] = assume[PhantomEqEq[Double]]
+  implicit def eqString: PhantomEqEq[String] = assume
+  implicit def eqInt: PhantomEqEq[Int]       = assume
+  implicit def eqDouble: PhantomEqEq[Double] = assume
 
-  implicit def eqByteNum: PhantomEq[Byte, Number] = assume[PhantomEq[Byte, Number]]
-  implicit def eqNumByte: PhantomEq[Number, Byte] = assume[PhantomEq[Number, Byte]]
+  implicit def eqByteNum: PhantomEq[Byte, Number] = assume
+  implicit def eqNumByte: PhantomEq[Number, Byte] = assume
 
-  implicit def eqSeq[T, U](implicit eq: PhantomEq[T, U]): PhantomEq[Seq[T], Seq[U]] =
-    assume[PhantomEq[Seq[T], Seq[U]]]
+  implicit def eqSeq[T, U](implicit eq: PhantomEq[T, U]): PhantomEq[Seq[T], Seq[U]] = assume
 
 }

tests/neg/phantom-bottom.scala

@@ -16,10 +16,10 @@ class Foo {
 object Boo extends Phantom {
   type BooAny = this.Any
   type BooNothing = this.Nothing
-  def nothing: BooNothing = assume[BooNothing]
+  def nothing: BooNothing = assume
 }
 
 object Boo2 extends Phantom {
   type BooNothing2 = this.Nothing
-  def nothing: BooNothing2 = assume[BooNothing2]
+  def nothing: BooNothing2 = assume
 }

tests/neg/phantom-evidence.scala

@@ -13,7 +13,7 @@ object WithNormalState extends Phantom {
 
   type =::=[From, To] <: this.Any
 
-  implicit inline def tpEquals[A]: A =::= A = assume[=::=[A, A]]
+  implicit inline def tpEquals[A]: A =::= A = assume
 
   trait State
   sealed trait On extends State

tests/neg/phantom-expr.scala

@@ -36,10 +36,10 @@ class Foo {
 
 object Boo extends Phantom {
   type BooAny = this.Any
-  def boo[B <: BooAny]: B = assume[B]
+  def boo[B <: BooAny]: B = assume
 }
 
 object Boo1 extends Phantom {
   type Boo1Any = this.Any
-  def boo1: Boo1Any = assume[Boo1Any]
+  def boo1: Boo1Any = assume
 }

tests/neg/phantom-fun-app.scala

@@ -20,5 +20,5 @@ object Boo extends Phantom {
   type BooAny = this.Any
   type Blinky <: BooAny
   type Pinky <: Blinky
-  def boo[B <: BooAny]: B = assume[B]
+  def boo[B <: BooAny]: B = assume
 }

tests/neg/phantom-instanceOf-1.scala

@@ -7,5 +7,5 @@ class phantomInstanceOf1 {
 }
 
 object Boo extends Phantom {
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/neg/phantom-instanceOf-2.scala

@@ -10,5 +10,5 @@ class phantomInstanceOf2 {
 object Boo extends Phantom {
   type BooAny <: this.Any
   type Blinky <: this.Any
-  def boo[B <: this.Any]: B = assume[B]
+  def boo[B <: this.Any]: B = assume
 }

tests/neg/phantom-type-param-bounds-1.scala

@@ -5,5 +5,5 @@ class phantomTypeParamBounds1 {
 }
 
 object Boo extends Phantom {
-  def boo[B <: this.Any]: B = assume[B]
+  def boo[B <: this.Any]: B = assume
 }

tests/neg/phantom-type-param-bounds-2.scala

@@ -9,5 +9,5 @@ class phantomTypeParamBounds2 {
 }
 
 object Boo extends Phantom {
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/pos/phantom-Eq.scala

@@ -31,12 +31,12 @@ object EqUtil extends Phantom {
     def ===[U] (y: U)(implicit ce: PhantomEq[T, U]) = x.equals(y)
   }
 
-  implicit def eqString: PhantomEqEq[String] = assume[PhantomEqEq[String]]
-  implicit def eqInt: PhantomEqEq[Int]       = assume[PhantomEqEq[Int]]
-  implicit def eqDouble: PhantomEqEq[Double] = assume[PhantomEqEq[Double]]
+  implicit def eqString: PhantomEqEq[String] = assume
+  implicit def eqInt: PhantomEqEq[Int]       = assume
+  implicit def eqDouble: PhantomEqEq[Double] = assume
 
-  implicit def eqByteNum: PhantomEq[Byte, Number] = assume[PhantomEq[Byte, Number]]
-  implicit def eqNumByte: PhantomEq[Number, Byte] = assume[PhantomEq[Number, Byte]]
+  implicit def eqByteNum: PhantomEq[Byte, Number] = assume
+  implicit def eqNumByte: PhantomEq[Number, Byte] = assume
 
-  implicit def eqSeq[T, U](implicit eq: PhantomEq[T, U]): PhantomEq[Seq[T], Seq[U]] = assume[PhantomEq[Seq[T], Seq[U]]]
+  implicit def eqSeq[T, U](implicit eq: PhantomEq[T, U]): PhantomEq[Seq[T], Seq[U]] = assume
 }

tests/pos/phantom-Eq2/Phantom-Eq_1.scala

@@ -9,12 +9,12 @@ object EqUtil extends Phantom {
     def ===[U] (y: U)(implicit ce: PhantomEq[T, U]) = x.equals(y)
   }
 
-  implicit def eqString: PhantomEqEq[String] = assume[PhantomEqEq[String]]
-  implicit def eqInt: PhantomEqEq[Int]       = assume[PhantomEqEq[Int]]
-  implicit def eqDouble: PhantomEqEq[Double] = assume[PhantomEqEq[Double]]
+  implicit def eqString: PhantomEqEq[String] = assume
+  implicit def eqInt: PhantomEqEq[Int]       = assume
+  implicit def eqDouble: PhantomEqEq[Double] = assume
 
-  implicit def eqByteNum: PhantomEq[Byte, Number] = assume[PhantomEq[Byte, Number]]
-  implicit def eqNumByte: PhantomEq[Number, Byte] = assume[PhantomEq[Number, Byte]]
+  implicit def eqByteNum: PhantomEq[Byte, Number] = assume
+  implicit def eqNumByte: PhantomEq[Number, Byte] = assume
 
-  implicit def eqSeq[T, U](implicit eq: PhantomEq[T, U]): PhantomEq[Seq[T], Seq[U]] = assume[PhantomEq[Seq[T], Seq[U]]]
+  implicit def eqSeq[T, U](implicit eq: PhantomEq[T, U]): PhantomEq[Seq[T], Seq[U]] = assume
 }

tests/run/phantom-1.scala

@@ -18,5 +18,5 @@ object Test {
 
 object Boo extends Phantom {
   type BooAny = this.Any
-  def any: BooAny = assume[BooAny]
+  def any: BooAny = assume
 }

tests/run/phantom-2.scala

@@ -16,5 +16,5 @@ object Test {
 
 object Boo extends Phantom {
   type BooNothing = this.Nothing
-  def nothig: BooNothing = assume[BooNothing] // Should be allowed?
+  def nothig: BooNothing = assume
 }

tests/run/phantom-3.scala

@@ -22,5 +22,5 @@ object Boo extends Phantom {
   type Inky <: Blinky
   type Pinky <: Inky
   type Casper = Pinky
-  def boo[B <: Blinky]: B = assume[B]
+  def boo[B <: Blinky]: B = assume
 }

tests/run/phantom-4.scala

@@ -23,5 +23,5 @@ object Boo extends Phantom {
   type Inky <: Blinky
   type Pinky <: Inky
   type Casper = Pinky
-  def boo[B <: Blinky]: B = assume[B]
+  def boo[B <: Blinky]: B = assume
 }

tests/run/phantom-5.scala

@@ -23,5 +23,5 @@ object Boo extends Phantom {
   type Pinky <: Inky
   type Clyde >: Pinky <: Inky
   type Casper = Pinky
-  def boo[B <: Blinky]: B = assume[B]
+  def boo[B <: Blinky]: B = assume
 }

tests/run/phantom-decls-1.scala

@@ -25,5 +25,5 @@ object Boo extends Phantom {
   type BooAny = this.Any
   type Blinky <: this.Any
   type Inky <: Blinky
-  def boo[B <: Blinky]: B = assume[B]
+  def boo[B <: Blinky]: B = assume
 }

tests/run/phantom-decls-2.scala

@@ -27,5 +27,5 @@ object Boo extends Phantom {
   type Inky <: Blinky
   type Pinky <: Inky
   type Casper = Pinky
-  def boo[B <: this.Any]: B = assume[B]
+  def boo[B <: this.Any]: B = assume
 }

tests/run/phantom-decls-3.scala

@@ -32,5 +32,5 @@ object Boo extends Phantom {
   type Blinky <: this.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: BooAny]: B = assume[B]
+  def boo[B <: BooAny]: B = assume
 }

tests/run/phantom-decls-4.scala

@@ -21,5 +21,5 @@ object Boo extends Phantom {
   type Blinky <: this.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Blinky]: B = assume[B]
+  def boo[B <: Blinky]: B = assume
 }

tests/run/phantom-decls-5.scala

@@ -20,5 +20,5 @@ object Boo extends Phantom {
   type Blinky <: this.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Blinky]: B = assume[B]
+  def boo[B <: Blinky]: B = assume
 }

tests/run/phantom-hk-1.scala

@@ -27,5 +27,5 @@ object Boo extends Phantom {
   type Blinky <: this.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: this.Any]: B = assume[B]
+  def boo[B <: this.Any]: B = assume
 }

tests/run/phantom-hk-2.scala

@@ -25,5 +25,5 @@ object Boo extends Phantom {
   type Blinky <: Boo.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-lazy-val.scala

@@ -23,5 +23,5 @@ object Test {
 
 object Boo extends Phantom {
   type BooAny = this.Any
-  def any: BooAny = assume[BooAny]
+  def any: BooAny = assume
 }

tests/run/phantom-methods-1.scala

@@ -18,5 +18,5 @@ object Test {
 object Boo extends Phantom {
   type BooAny = Boo.Any
   type Pinky <: Boo.Any
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-methods-10.scala

@@ -27,5 +27,5 @@ object Test {
 
 object Boo extends Phantom {
   type Inky <: this.Any
-  def boo[B <: this.Any]: B = assume[B]
+  def boo[B <: this.Any]: B = assume
 }

tests/run/phantom-methods-2.scala

@@ -22,5 +22,5 @@ object Boo extends Phantom {
   type Blinky <: Boo.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-methods-3.scala

@@ -22,5 +22,5 @@ object Boo extends Phantom {
   type Blinky <: Boo.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-methods-4.scala

@@ -22,5 +22,5 @@ object Boo extends Phantom {
   type Blinky <: Boo.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-methods-5.scala

@@ -22,5 +22,5 @@ object Boo extends Phantom {
   type Blinky <: Boo.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-methods-6.scala

@@ -20,5 +20,5 @@ object Boo extends Phantom {
   type Blinky <: Boo.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-methods-7.scala

@@ -20,5 +20,5 @@ object Boo extends Phantom {
   type Inky <: Boo.Any
   type Pinky <: Inky
   type Clyde >: Pinky <: Inky
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-methods-8.scala

@@ -22,5 +22,5 @@ object Test {
 
 object Boo extends Phantom {
   type Inky <: Boo.Any
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-methods-9.scala

@@ -27,5 +27,5 @@ object Test {
 
 object Boo extends Phantom {
   type Inky <: Boo.Any
-  def boo[B <: Boo.Any]: B = assume[B]
+  def boo[B <: Boo.Any]: B = assume
 }

tests/run/phantom-poly-1.scala

@@ -19,5 +19,5 @@ object Test {
 
 object Boo extends Phantom {
   type Casper <: this.Any
-  def boo[B <: this.Any]: B = assume[B]
+  def boo[B <: this.Any]: B = assume
 }

tests/run/phantom-poly-2.scala

@@ -21,5 +21,5 @@ object Boo extends Phantom {
   type Blinky <: this.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: this.Any]: B = assume[B]
+  def boo[B <: this.Any]: B = assume
 }

tests/run/phantom-poly-3.scala

@@ -22,5 +22,5 @@ object Boo extends Phantom {
   type Blinky <: this.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Blinky]: B = assume[B]
+  def boo[B <: Blinky]: B = assume
 }

tests/run/phantom-poly-4.scala

@@ -22,5 +22,5 @@ object Boo extends Phantom {
   type Blinky <: this.Any
   type Inky <: Blinky
   type Pinky <: Inky
-  def boo[B <: Blinky]: B = assume[B]
+  def boo[B <: Blinky]: B = assume
 }

tests/run/phantom-val.scala

@@ -22,5 +22,5 @@ object Test {
 
 object Boo extends Phantom {
   type BooAny = this.Any
-  def any: BooAny = assume[BooAny]
+  def any: BooAny = assume
 }