Restore the specified behavior of j.l.Class.isAssignableFrom.

The implemented behavior used to match the specification, but was
changed in 9108b7c to fix scala-js#879.

It turns out that the real culprit for scala-js#879 was not
`isAssignableFrom`, but the implementation of `ClassTag.unapply`.
Now that the latter has a Scala.js-friendly implementation in all
versions of Scala for which it is not also broken on the JVM, we
do not need `isAssignableFrom` to work around it.

This makes sure that the behavior of `java.lang.Class` is not
dependent on Scala as a source language.

One partest does not pass out-of-the-box in 2.11.x if we do that:
`run/t6318_primitives.scala`, but it works in 2.12.x. That happens
because 2.12.x removed the overloads taking primitives, so at a
source call site of `ct.unapply(5)`, 2.11.x would call
`unapply(Int)` but 2.12+ would call `unapply(Any)`. It turns out
that the `unapply`s taking primitives are not Scala.js-friendly
enough for this partest (which has an overridden check file, btw).
We fix this by "backporting" from 2.12 the removal of the
`unapply`s taking any. In practice we cannot do that because we
need to preserve binary compatibility, but we can implement it
anyway by overriding them to delegate to the `unapply` taking
`Any`.

Author: sjrd

javalanglib/src/main/scala/java/lang/Class.scala

@@ -30,27 +30,8 @@ final class Class[A] private (data: ScalaJSClassData[A]) extends Object {
     data.isInstance(obj)
 
   def isAssignableFrom(that: Class[_]): scala.Boolean =
-    if (this.isPrimitive || that.isPrimitive) {
-      /* This differs from the JVM specification to mimic the behavior of
-       * runtime type tests of primitive numeric types.
-       */
-      (this eq that) || {
-        if (this eq classOf[scala.Short])
-          (that eq classOf[scala.Byte])
-        else if (this eq classOf[scala.Int])
-          (that eq classOf[scala.Byte]) || (that eq classOf[scala.Short])
-        else if (this eq classOf[scala.Float])
-          (that eq classOf[scala.Byte]) || (that eq classOf[scala.Short]) ||
-          (that eq classOf[scala.Int])
-        else if (this eq classOf[scala.Double])
-          (that eq classOf[scala.Byte]) || (that eq classOf[scala.Short]) ||
-          (that eq classOf[scala.Int])  || (that eq classOf[scala.Float])
-        else
-          false
-      }
-    } else {
-      this.isInstance(that.getFakeInstance())
-    }
+    if (this.isPrimitive || that.isPrimitive) this eq that
+    else this.isInstance(that.getFakeInstance())
 
   private def getFakeInstance(): Object =
     data.getFakeInstance()

scalalib/overrides-2.11/scala/reflect/ClassTag.scala

@@ -84,19 +84,15 @@ trait ClassTag[T] extends ClassManifestDeprecatedApis[T] with Equals with Serial
     else None
 
   // TODO: deprecate overloads in 2.12.0, remove in 2.13.0
-  def unapply(x: Byte)    : Option[T] = unapplyImpl(x, classOf[Byte])
-  def unapply(x: Short)   : Option[T] = unapplyImpl(x, classOf[Short])
-  def unapply(x: Char)    : Option[T] = unapplyImpl(x, classOf[Char])
-  def unapply(x: Int)     : Option[T] = unapplyImpl(x, classOf[Int])
-  def unapply(x: Long)    : Option[T] = unapplyImpl(x, classOf[Long])
-  def unapply(x: Float)   : Option[T] = unapplyImpl(x, classOf[Float])
-  def unapply(x: Double)  : Option[T] = unapplyImpl(x, classOf[Double])
-  def unapply(x: Boolean) : Option[T] = unapplyImpl(x, classOf[Boolean])
-  def unapply(x: Unit)    : Option[T] = unapplyImpl(x, classOf[Unit])
-
-  private[this] def unapplyImpl(x: Any, primitiveCls: java.lang.Class[_]): Option[T] =
-    if (runtimeClass.isInstance(x) || runtimeClass.isAssignableFrom(primitiveCls)) Some(x.asInstanceOf[T])
-    else None
+  def unapply(x: Byte)    : Option[T] = unapply(x: Any)
+  def unapply(x: Short)   : Option[T] = unapply(x: Any)
+  def unapply(x: Char)    : Option[T] = unapply(x: Any)
+  def unapply(x: Int)     : Option[T] = unapply(x: Any)
+  def unapply(x: Long)    : Option[T] = unapply(x: Any)
+  def unapply(x: Float)   : Option[T] = unapply(x: Any)
+  def unapply(x: Double)  : Option[T] = unapply(x: Any)
+  def unapply(x: Boolean) : Option[T] = unapply(x: Any)
+  def unapply(x: Unit)    : Option[T] = unapply(x: Any)
 
   // case class accessories
   override def canEqual(x: Any) = x.isInstanceOf[ClassTag[_]]

test-suite/js/src/test/scala/org/scalajs/testsuite/compiler/ReflectionTest.scala

@@ -125,16 +125,6 @@ class ReflectionTest {
     assertEquals(classOf[scala.runtime.BoxedUnit], ((): Any).getClass)
   }
 
-  @Test def class_isAssignableFrom_should_mimic_runtime_type_tests_behavior_issue_879(): Unit = {
-    assertTrue(classOf[Short].isAssignableFrom(classOf[Byte]))
-    assertTrue(classOf[Byte].isAssignableFrom(classOf[Byte]))
-    assertFalse(classOf[Byte].isAssignableFrom(classOf[Short]))
-    assertTrue(classOf[Int].isAssignableFrom(classOf[Byte]))
-    assertTrue(classOf[Double].isAssignableFrom(classOf[Int]))
-    assertFalse(classOf[Int].isAssignableFrom(classOf[Double]))
-    assertFalse(classOf[Long].isAssignableFrom(classOf[Int]))
-  }
-
   @Test def getSuperclass_issue_1489(): Unit = {
     assertEquals(classOf[SomeParentClass], classOf[SomeChildClass].getSuperclass)
     assertNull(classOf[AnyRef].getSuperclass)

test-suite/shared/src/test/scala/org/scalajs/testsuite/javalib/lang/ClassTest.scala

@@ -14,6 +14,18 @@ import scala.runtime.BoxedUnit
 
 class ClassTest {
 
+  private val PrimitiveClassOfs = Seq(
+      classOf[Unit],
+      classOf[Boolean],
+      classOf[Char],
+      classOf[Byte],
+      classOf[Short],
+      classOf[Int],
+      classOf[Long],
+      classOf[Float],
+      classOf[Double]
+  )
+
   @Test def getPrimitiveTypeName(): Unit = {
     assertEquals("void", classOf[Unit].getName)
     assertEquals("boolean", classOf[Boolean].getName)
@@ -57,6 +69,38 @@ class ClassTest {
     assertEquals("InnerClass", classOf[ClassTestClass#InnerClass].getSimpleName())
   }
 
+  @Test def isAssignableFrom(): Unit = {
+    val SelectedClassOfs =
+      PrimitiveClassOfs ++ Seq(classOf[Object], classOf[String])
+
+    // All Classes are assignable from themselves
+    for (cls <- SelectedClassOfs) {
+      assertTrue(s"$cls should be assignable from itself",
+          cls.isAssignableFrom(cls))
+    }
+
+    // Otherwise, if one side is a primitive, the result must be false
+    for {
+      left <- SelectedClassOfs
+      right <- SelectedClassOfs
+      if (left ne right) && (left.isPrimitive || right.isPrimitive)
+    } {
+      assertFalse(
+          s"$left.isAssignableFrom($right) should be false",
+          left.isAssignableFrom(right))
+    }
+
+    assertTrue(classOf[Object].isAssignableFrom(classOf[String]))
+    assertTrue(classOf[Seq[_]].isAssignableFrom(classOf[List[_]]))
+    assertTrue(classOf[Object].isAssignableFrom(classOf[Array[String]]))
+    assertTrue(classOf[Array[Seq[_]]].isAssignableFrom(classOf[Array[List[_]]]))
+
+    assertFalse(classOf[String].isAssignableFrom(classOf[Object]))
+    assertFalse(classOf[List[_]].isAssignableFrom(classOf[Seq[_]]))
+    assertFalse(classOf[Array[String]].isAssignableFrom(classOf[Object]))
+    assertFalse(classOf[Array[List[_]]].isAssignableFrom(classOf[Array[Seq[_]]]))
+  }
+
   @Test def getComponentType(): Unit = {
     @noinline
     def testNoInline(clazz: Class[_], componentType: Class[_]): Unit =