WIP

Author: nicolasstucki

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

@@ -386,7 +386,10 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         import untpd._
         val x = tpnme.ANON_CLASS
         val clsDef = TypeDef(x, templ).withFlags(Final)
-        typed(cpy.Block(tree)(clsDef :: Nil, New(Ident(x), Nil)), pt)
+        val typedBlock = typed(cpy.Block(tree)(clsDef :: Nil, New(Ident(x), Nil)), pt)
+        if (typedBlock.tpe.derivesFrom(defn.PhantomAnyClass))
+          ctx.error("Cannot instantiate anonymous phantom classes.", tree.pos)
+        typedBlock
       case _ =>
         var tpt1 = typedType(tree.tpt)
         tpt1.tpe.dealias match {
@@ -576,6 +579,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val cond1 = typed(tree.cond, defn.BooleanType)
     val thenp1 = typed(tree.thenp, pt)
     val elsep1 = typed(tree.elsep orElse (untpd.unitLiteral withPos tree.pos), pt)
+    checkNotPhantomExpr("Cannot yield a phantom type in one of the if branches", thenp1)
+    checkNotPhantomExpr("Cannot yield a phantom type in one of the if branches", elsep1)
     val thenp2 :: elsep2 :: Nil = harmonize(thenp1 :: elsep1 :: Nil)
     assignType(cpy.If(tree)(cond1, thenp2, elsep2), thenp2, elsep2)
   }
@@ -744,6 +749,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         typed(desugar.makeCaseLambda(tree.cases, protoFormals.length) withPos tree.pos, pt)
       case _ =>
         val sel1 = typedExpr(tree.selector)
+        checkNotPhantomExpr("Cannot pattern match on phantom objects", sel1)
         val selType = widenForMatchSelector(
             fullyDefinedType(sel1.tpe, "pattern selector", tree.pos))
 
@@ -814,6 +820,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       val guard1 = typedExpr(tree.guard, defn.BooleanType)
       val body1 = ensureNoLocalRefs(typedExpr(tree.body, pt), pt, ctx.scope.toList)
         .ensureConforms(pt)(originalCtx) // insert a cast if body does not conform to expected type if we disregard gadt bounds
+      checkNotPhantomExpr("Pattern matches cannot return phantom objects", body1)
       assignType(cpy.CaseDef(tree)(pat1, guard1, body1), body1)
     }
 
@@ -870,6 +877,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         (from, proto)
       }
     val expr1 = typedExpr(tree.expr orElse untpd.unitLiteral.withPos(tree.pos), proto)
+    checkNotPhantomExpr("Cannot use 'return' with phantom objects", expr1)
     assignType(cpy.Return(tree)(expr1, from))
   }
 
@@ -879,6 +887,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val finalizer1 = typed(tree.finalizer, defn.UnitType)
     val expr2 :: cases2x = harmonize(expr1 :: cases1)
     val cases2 = cases2x.asInstanceOf[List[CaseDef]]
+    checkNotPhantomExpr("Cannot return a phantom object in a try", expr2)
     assignType(cpy.Try(tree)(expr2, cases2, finalizer1), expr2, cases2)
   }
 
@@ -1855,4 +1864,10 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       }
     }
   }
+
+  private def checkNotPhantomExpr(msg: => String, expr: Tree)(implicit ctx: Context): Unit = {
+    if (expr.tpe.derivesFrom(defn.PhantomAnyClass))
+      ctx.error(msg, expr.pos)
+  }
+
 }

tests/neg/phantomClass4.scala

@@ -0,0 +1,11 @@
+import dotty.phantom.PhantomAny
+
+class Blinky extends PhantomAny {
+  def boo1 = new PhantomAny {} // error
+  def boo2 = new Inky {} // error
+  def boo3 = new Pinky {} // error
+}
+
+abstract class Inky extends PhantomAny
+
+trait Pinky extends PhantomAny

tests/neg/phantomExpr.scala

@@ -0,0 +1,22 @@
+import dotty.phantom.PhantomAny
+
+object Blinky extends PhantomAny
+object Inky extends PhantomAny
+
+class Foo {
+  val b = true
+  def fooIf1 = if (b) { Blinky } else { Inky } // error // error
+//  def fooIf2 = if (b) { Blinky } else { "" } // FIXME: emmits error but than crashes
+//  def fooIf3 = if (b) { "" } else { Blinky } // FIXME: emmits error but than crashes
+
+  def fooMatch1 = Blinky match { case Blinky => () } // error
+  def fooMatch2 = 1 match { case _ => Blinky } // error
+  def fooMatch3 = 1 match { case Blinky => () } // error
+
+//  def fooTry1 = try { Blinky } catch { case e: Throwable => } // FIXME: emmits error but than crashes
+//  def fooTry2 = try { } catch { case e: Throwable => Blinky } // FIXME: emmits error but than crashes
+
+  def fooReturn1: PhantomAny = return Blinky // error // error
+  def fooReturn2 = return Blinky // error // error
+
+}

tests/neg/phantomExpr2.scala

@@ -0,0 +1,8 @@
+import dotty.phantom.PhantomAny
+
+object Blinky extends PhantomAny
+object Inky extends PhantomAny
+
+class Foo {
+  def fooTry1 = try { } finally { Blinky } // error
+}

tests/run/phantom.check

@@ -1,6 +1,7 @@
 fun1
 fun1
 fun1
+fun1
 fun2
 fun2
 fun2
@@ -18,20 +19,23 @@ polyfun2
 polyfun2
 polyfun2
 polyfun2
+polyfun2
 Boo6
 polyfun3
 Boo6
 polyfun3
 polyfun3
 polyfun3
 polyfun3
+polyfun3
 Boo6
 polyfun4
 Boo6
 polyfun4
 polyfun4
 polyfun4
 polyfun4
+polyfun4
 Boo1
 Boo1.polyfun1
 Boo1

tests/run/phantom.scala

@@ -8,104 +8,114 @@ object Test {
   import dotty.phantom.PhantomNothing
   import Phantoms._
 
+  trait Phantoms {
+    type Clyde >: Pinky <: Inky
+  }
+
+  object Phantoms extends Phantoms {
+    trait Blinky extends PhantomAny
+    abstract class Inky extends Blinky
+    class Pinky extends Inky
+    object Moroi extends Pinky
+  }
+
   def main(args: Array[String]): Unit = {
-    fun1(new Blinky {})
-    fun1(new Inky {})
+    class BlinkyImpl extends Blinky
+    class InkyImpl extends Inky
+
+    fun1(new BlinkyImpl)
+    fun1(new InkyImpl)
     fun1(new Pinky)
+    fun1(Moroi)
 
-    fun3(new Blinky {}, new Pinky)
-    fun3(new Inky {}, new Pinky)
-    fun3(new Pinky, new Pinky)
+    fun3(new BlinkyImpl, new Pinky)
+    fun3(new InkyImpl, new Pinky)
+    fun3(new Pinky, Moroi)
 
-    fun4(3, 4)(new Blinky {}, new Pinky)
-    fun4(5, 6)(new Inky {}, new Pinky)
-    fun4(7, 8)(new Pinky, new Pinky)
+    fun4(3, 4)(new BlinkyImpl, new Pinky)
+    fun4(5, 6)(new InkyImpl, new Pinky)
+    fun4(7, 8)(new Pinky, Moroi)
 
-    fun5(new Blinky {}, new Pinky)(15, 16)
-    fun5(new Inky {}, new Pinky)(17, 18)
-    fun5(new Pinky, new Pinky)(19, 20)
+    fun5(new BlinkyImpl, new Pinky)(15, 16)
+    fun5(new InkyImpl, new Pinky)(17, 18)
+    fun5(new Pinky, Moroi)(19, 20)
 
     polyfun1()
 
     polyfun2(new Boo6().boo1)
     polyfun2(new Boo6().boo2)
-    println("polyfun2") // polyfun2(new Blinky {}) // FIXME: error: Type argument (Object & Test.Phantoms.Blinky)' does not conform to lower bound PhantomNothing
-    polyfun2(new Inky {})
+    polyfun2(new BlinkyImpl)
+    polyfun2(new InkyImpl)
     polyfun2(new Pinky)
+    polyfun2(Moroi)
 
     polyfun3(new Boo6().boo1)
     polyfun3(new Boo6().boo2)
-    println("polyfun3") // polyfun3(new Blinky {}) FIXME
-    polyfun3(new Inky {})
+    polyfun3(new BlinkyImpl)
+    polyfun3(new InkyImpl)
     polyfun3(new Pinky)
+    polyfun3(Moroi)
 
     polyfun4(new Boo6().boo1)
     polyfun4(new Boo6().boo2)
-    println("polyfun4") // polyfun4(new Blinky {}) FIXME
-    polyfun4(new Inky {})
+    polyfun4(new BlinkyImpl)
+    polyfun4(new InkyImpl)
     polyfun4(new Pinky)
+    polyfun4(Moroi)
 
-    new Boo1[PhantomAny]().polyfun1(new Blinky {})
-    new Boo1[PhantomAny]().polyfun1(new Inky {})
+    new Boo1[PhantomAny]().polyfun1(new BlinkyImpl)
+    new Boo1[PhantomAny]().polyfun1(new InkyImpl)
 
-    new Boo2().polyfun1(new Blinky {})
-    new Boo2().polyfun1(new Inky {})
+    new Boo2().polyfun1(new BlinkyImpl)
+    new Boo2().polyfun1(new InkyImpl)
     new Boo2().polyfun1(new Pinky)
 
     new Boo3(){
       type Boo = PhantomAny
     }.polyfun1(new Pinky)
     new Boo3(){
       type Boo = Blinky
-    }.polyfun1(new Blinky {})
+    }.polyfun1(new BlinkyImpl)
 
-    new Boo4(new Blinky {})
-    new Boo4(new Inky {})
+    new Boo4(new BlinkyImpl)
+    new Boo4(new InkyImpl)
     new Boo4(new Pinky)
 
     new Boo5[PhantomAny](new Pinky)
     new Boo5[Pinky](new Pinky)
 
     fun(phantomFun1())
 
-    fun(phantomFun2(new Blinky {}))
-    fun(phantomFun2(new Inky {}))
+    fun(phantomFun2(new BlinkyImpl))
+    fun(phantomFun2(new InkyImpl))
     fun(phantomFun2(new Pinky))
 
-    // fun(phantomFun3(new Blinky {})) FIXME
-    fun(phantomFun3(new Inky {}))
+    fun(phantomFun3(new BlinkyImpl))
+    fun(phantomFun3(new InkyImpl))
     fun(phantomFun3(new Pinky))
 
-    // fun(phantomFun4(new Blinky {})) FIXME
-    fun(phantomFun4(new Inky {}))
+    fun(phantomFun4(new BlinkyImpl))
+    fun(phantomFun4(new InkyImpl))
     fun(phantomFun4(new Pinky))
 
-    pacFun1(new Blinky {})
-    pacFun1(new Inky {})
+    pacFun1(new BlinkyImpl)
+    pacFun1(new InkyImpl)
     pacFun1(new Pinky)
 
     pacFun2(new Pinky)
 
     pacFun3(new Pinky)
 
-    println("hkFun1") // hkFun1(new Blinky {}) // FIXME
-    hkFun1(new Inky {})
+    hkFun1(new BlinkyImpl)
+    hkFun1(new InkyImpl)
     hkFun1(new Pinky)
 
-    // fun(hkFun2(new Blinky {})) FIXME
-    fun(hkFun2(new Inky {}))
+    fun(hkFun2(new BlinkyImpl))
+    fun(hkFun2(new InkyImpl))
     fun(hkFun2(new Pinky))
   }
 
-  trait Phantoms {
-    type Clyde >: Pinky <: Inky
-  }
 
-  object Phantoms extends Phantoms {
-    trait Blinky extends PhantomAny
-    abstract class Inky extends Blinky
-    class Pinky extends Inky
-  }
 
   def fun(top: PhantomAny): Unit = ()