Merge pull request scala#6155 from milessabin/topic/any-nothing-tests

More precise check for Any/Nothing, ruling out singleton types

Author: adriaanm

src/reflect/scala/reflect/internal/Types.scala

@@ -3252,12 +3252,14 @@ trait Types
        *  }}}
        */
       def unifySimple = {
-        val sym = tp.typeSymbol
-        if (sym == NothingClass || sym == AnyClass) { // kind-polymorphic
-          // scala/bug#7126 if we register some type alias `T=Any`, we can later end
-          // with malformed types like `T[T]` during type inference in
-          // `handlePolymorphicCall`. No such problem if we register `Any`.
-          addBound(sym.tpe)
+        // scala/bug#7126 if we register some type alias `T=Any`, we can later end
+        // with malformed types like `T[T]` during type inference in
+        // `handlePolymorphicCall`. No such problem if we register `Any`.
+        if (typeIsNothing(tp)) { // kind-polymorphic
+          addBound(NothingTpe)
+          true
+        } else if(typeIsAny(tp)) { // kind-polymorphic
+          addBound(AnyTpe)
           true
         } else if (params.isEmpty) {
           addBound(tp)
@@ -4852,8 +4854,23 @@ trait Types
   private[scala] val boundsContainType = (bounds: TypeBounds, tp: Type) => bounds containsType tp
   private[scala] val typeListIsEmpty = (ts: List[Type]) => ts.isEmpty
   private[scala] val typeIsSubTypeOfSerializable = (tp: Type) => tp <:< SerializableTpe
-  private[scala] val typeIsNothing = (tp: Type) => tp.typeSymbolDirect eq NothingClass
-  private[scala] val typeIsAny = (tp: Type) => tp.typeSymbolDirect eq AnyClass
+
+  @tailrec
+  private[scala] final def typeIsNothing(tp: Type): Boolean =
+    tp.dealias match {
+      case PolyType(_, tp) => typeIsNothing(tp)
+      case TypeRef(_, NothingClass, _) => true
+      case _ => false
+    }
+
+  @tailrec
+  private[scala] final def typeIsAny(tp: Type): Boolean =
+    tp.dealias match {
+      case PolyType(_, tp) => typeIsAny(tp)
+      case TypeRef(_, AnyClass, _) => true
+      case _ => false
+    }
+
   private[scala] val typeIsHigherKinded = (tp: Type) => tp.isHigherKinded
 
   /** The maximum depth of type `tp` */

src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala

@@ -127,10 +127,7 @@ private[internal] trait TypeConstraints {
     def addHiBound(tp: Type, isNumericBound: Boolean = false) {
       // My current test case only demonstrates the need to let Nothing through as
       // a lower bound, but I suspect the situation is symmetrical.
-      val mustConsider = tp.typeSymbol match {
-        case AnyClass => true
-        case _        => !(hibounds contains tp)
-      }
+      val mustConsider = typeIsAny(tp) || !(hibounds contains tp)
       if (mustConsider) {
         checkWidening(tp)
         if (isNumericBound && isNumericValueType(tp)) {

test/junit/scala/reflect/internal/TypesTest.scala

@@ -313,4 +313,16 @@ class TypesTest {
       assert(polyType(A => Bar(Int, A)) <:< _F && _F <:< polyType(A => Bar(Any, A)))
     }
   }
+
+  @Test
+  def testAnyNothing(): Unit = {
+    object Foo { val a: Any = 23 ; val n: Nothing = ??? }
+    val aSym = typeOf[Foo.type].member(TermName("a"))
+    val nSym = typeOf[Foo.type].member(TermName("n"))
+
+    assert(typeIsAny(AnyTpe))
+    assert(typeIsNothing(NothingTpe))
+    assert(!typeIsAny(SingleType(NoPrefix, aSym)))
+    assert(!typeIsNothing(SingleType(NoPrefix, nSym)))
+  }
 }