Disallow phantom type parameter/member in classes

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

@@ -473,6 +473,16 @@ object Checking {
       stats.foreach(checkValueClassMember)
     }
   }
+
+  /** Verify type definitions meet the requirements */
+  def checkTypeDef(tdef: tpd.TypeDef)(implicit ctx: Context): Unit = {
+    val isParam = tdef.tpe.typeSymbol.is(Param)
+    val isPhantom = tdef.tpe.isPhantom
+    if (isParam && isPhantom && tdef.symbol.owner.isPrimaryConstructor)
+      ctx.error("Classes cannot have phantom type parameters", tdef.pos)
+    else if (!isParam && isPhantom && !tdef.symbol.owner.isStaticOwner)
+      ctx.error("Non static classes cannot have phantom type members", tdef.pos)
+  }
 }
 
 trait Checking {

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

@@ -1261,7 +1261,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case rhs =>
         typedType(rhs)
     }
-    assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
+    val tdef1 = assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
+    Checking.checkTypeDef(tdef1)
+    tdef1
   }
 
   def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context) = track("typedClassDef") {

tests/neg/phantom-bottom.scala

@@ -10,7 +10,7 @@ class BooFunDef1 {
 }
 
 class Foo {
-  type Y <: Boo.BooAny
+  type Y <: Boo.BooAny // error
 }
 
 object Boo extends Phantom {

tests/neg/phantom-class-type-members.scala

@@ -0,0 +1,37 @@
+import Boo._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val a = new Bar()
+    foo(a.asInstanceOf[Foo{type T = BooNothing}].y)  // error
+
+    val b = new Baz
+    b.asInstanceOf[Foo{type T = BooAny}].z(any)  // error
+  }
+
+  def foo(x: BooNothing) = println("foo")
+
+}
+
+abstract class Foo {
+  type T <: BooAny // error
+  def y: T
+  def z(z: T) = ()
+}
+
+class Bar {
+  type T = BooAny // error
+  def y: T = any
+  def z(z: T) = ()
+}
+
+class Baz {
+  type T = BooNothing // error
+  def z(z: T) = ()
+}
+
+object Boo extends Phantom {
+  type BooAny = this.Any
+  type BooNothing = this.Nothing
+  def any: BooAny = assume
+}

tests/neg/phantom-class-type-parameters.scala

@@ -0,0 +1,26 @@
+import Boo._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val a = new Foo[BooAny](any)
+    foo(a.asInstanceOf[Foo[BooNothing]].x) // should not be possible
+    foo(a.asInstanceOf[Foo[BooNothing]].y) // should not be possible
+
+    val b = new Foo[BooNothing](a.asInstanceOf[Foo[BooNothing]].x)
+    b.asInstanceOf[Foo[BooAny]].z(any) // should not be possible
+  }
+
+  def foo(x: BooNothing) = println("foo")
+
+}
+
+class Foo[T <: BooAny](val x: T) { // error
+  def y: T = x
+  def z(z: T) = ()
+}
+
+object Boo extends Phantom {
+  type BooAny = this.Any
+  type BooNothing = this.Nothing
+  def any: BooAny = assume
+}

tests/neg/phantom-classOf-2.scala

@@ -1,10 +1,8 @@
 
 class phantomClassOf {
-  type Blinky <: Boo.BooAny
-
-  classOf[Blinky] // error
+  classOf[Boo.Blinky] // error
 }
 
 object Boo extends Phantom {
-  type BooAny = this.Any
+  type Blinky = this.Any
 }

tests/run/phantom-decls-1.scala → tests/neg/phantom-decls-1.scala

@@ -13,7 +13,7 @@ object Test {
 
   def fun(top: BooAny): Unit = ()
 
-  class Boo1[P <: BooAny] {
+  class Boo1[P <: BooAny] { // error
     println("Boo1")
     def polyfun1(p1: P): Unit = {
       println("Boo1.polyfun1")

tests/run/phantom-decls-5.scala → tests/neg/phantom-decls-5.scala

@@ -11,7 +11,7 @@ object Test {
     new Boo5[Pinky](boo[Pinky])
   }
 
-  class Boo5[P <: Blinky](p5: P) {
+  class Boo5[P <: Blinky](p5: P) { // error
     println("Boo5")
   }
 }

tests/neg/phantom-expr.scala

@@ -3,9 +3,6 @@ class Foo {
   import Boo._
   import Boo1._
 
-  type Blinky <: BooAny
-  type Inky <: BooAny
-
   val blinky = Boo.boo[Blinky]
   val inky = Boo.boo[Inky]
 
@@ -40,6 +37,8 @@ class Foo {
 
 object Boo extends Phantom {
   type BooAny = this.Any
+  type Blinky <: BooAny
+  type Inky <: BooAny
   def boo[B <: BooAny]: B = assume
 }
 

tests/run/phantom-decls-2.scala

@@ -12,9 +12,10 @@ object Test {
     new Boo2().polyfun1(boo[Pinky])
   }
 
+  type Boo3 = BooAny
+
   class Boo2 {
     println("Boo2")
-    type Boo3 = BooAny
     def polyfun1(p2: Boo3): Unit = {
       println("Boo2.polyfun1")
     }

tests/run/phantom-decls-3.scala

@@ -7,20 +7,14 @@ object Test {
   import Boo._
 
   def main(args: Array[String]): Unit = {
-
-    new Boo3(){
-      type Boo1 = BooAny
-    }.polyfun1(boo[Pinky])
-
-    new Boo3(){
-      type Boo1 = Blinky
-    }.polyfun1(boo[Blinky])
-
+    new Boo3(){ }.polyfun1(boo[Pinky])
+    new Boo3(){ }.polyfun1(boo[Blinky])
   }
 
+  type Boo1 = BooAny
+
   trait Boo3 {
     println("Boo3")
-    type Boo1 <: BooAny
     def polyfun1(p3: Boo1): Unit = {
       println("Boo3.polyfun1")
     }