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

SingletonTypes can have Any as their typeSymbol, confusing kinding and
bounds checking logic.

Prior to this commit there were several places where it was assumed that
tpe.typeSymbol(Direct) == AnyClass tells us that tpe is Any. This
confused bounds and kind checking in circumstances which arise where
singleton types of values of subtypes Any are expressible (ie. via
literal types) because these SingleTypes delegate typeSymbol(Direct) to
their underlying, which is Any. Mutatis mutandis for Nothing.

The various instances of these tests have been consolidated under
typeIsAny and typeIsNothing in Types. In addition these have been
changed from function values to methods to improve performance.

Author: milessabin

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)
@@ -4851,8 +4853,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)))
+  }
 }