Merge pull request scala-js#2150 from sjrd/reftype-not-subtype-of-type

Do not make ReferenceType extend Type anymore.

Author: gzm0

ir/src/main/scala/org/scalajs/core/ir/Hashers.scala

@@ -265,12 +265,12 @@ object Hashers {
         case IsInstanceOf(expr, cls) =>
           mixTag(TagIsInstanceOf)
           mixTree(expr)
-          mixType(cls)
+          mixRefType(cls)
 
         case AsInstanceOf(expr, cls) =>
           mixTag(TagAsInstanceOf)
           mixTree(expr)
-          mixType(cls)
+          mixRefType(cls)
 
         case Unbox(expr, charCode) =>
           mixTag(TagUnbox)
@@ -416,7 +416,7 @@ object Hashers {
 
         case ClassOf(cls) =>
           mixTag(TagClassOf)
-          mixType(cls)
+          mixRefType(cls)
 
         case VarRef(ident) =>
           mixTag(TagVarRef)
@@ -443,6 +443,9 @@ object Hashers {
     def mixTrees(trees: List[Tree]): Unit =
       trees.foreach(mixTree)
 
+    def mixRefType(tpe: ReferenceType): Unit =
+      mixType(tpe.asInstanceOf[Type])
+
     def mixType(tpe: Type): Unit = tpe match {
       case AnyType     => mixTag(TagAnyType)
       case NothingType => mixTag(TagNothingType)

ir/src/main/scala/org/scalajs/core/ir/Printers.scala

@@ -473,13 +473,13 @@ object Printers {
         case IsInstanceOf(expr, cls) =>
           print(expr)
           print(".isInstanceOf[")
-          print(cls)
+          printRefType(cls)
           print(']')
 
         case AsInstanceOf(expr, cls) =>
           print(expr)
           print(".asInstanceOf[")
-          print(cls)
+          printRefType(cls)
           print(']')
 
         case Unbox(expr, charCode) =>
@@ -727,7 +727,7 @@ object Printers {
 
         case ClassOf(cls) =>
           print("classOf[")
-          print(cls)
+          printRefType(cls)
           print(']')
 
         // Specials
@@ -844,6 +844,9 @@ object Printers {
       }
     }
 
+    def printRefType(tpe: ReferenceType): Unit =
+      print(tpe.asInstanceOf[Type])
+
     def print(tpe: Type): Unit = tpe match {
       case AnyType              => print("any")
       case NothingType          => print("nothing")

ir/src/main/scala/org/scalajs/core/ir/Serializers.scala

@@ -521,7 +521,7 @@ object Serializers {
     }
 
     def writeReferenceType(tpe: ReferenceType): Unit =
-      writeType(tpe)
+      writeType(tpe.asInstanceOf[Type])
 
     def writePropertyName(name: PropertyName): Unit = {
       name match {

ir/src/main/scala/org/scalajs/core/ir/Trees.scala

@@ -375,7 +375,7 @@ object Trees {
     val tpe = cls match {
       case ClassType(Definitions.RuntimeNullClass)    => NullType
       case ClassType(Definitions.RuntimeNothingClass) => NothingType
-      case _                                          => cls
+      case _                                          => cls.asInstanceOf[Type]
     }
   }
 

ir/src/main/scala/org/scalajs/core/ir/Types.scala

@@ -15,7 +15,19 @@ import Trees._
 
 object Types {
 
-  /** Type of an expression in the IR. */
+  /** Type of an term (expression or statement) in the IR.
+   *
+   *  There is a many-to-one relationship from [[ReferenceType]]s to types,
+   *  because:
+   *
+   *  - `scala.Byte`, `scala.Short` and `scala.Int` collapse to [[IntType]]
+   *  - `java.lang.Object` and raw JS types all collapse to [[AnyType]]
+   *
+   *  In fact, there are two `Type`s that do not have any real equivalent in
+   *  reference types: [[StringType]] and [[UndefType]], as they refer to the
+   *  non-null variants of `java.lang.String` and `scala.runtime.BoxedUnit`,
+   *  respectively.
+   */
   abstract sealed class Type {
     def show(): String = {
       val writer = new java.io.StringWriter
@@ -83,14 +95,29 @@ object Types {
    */
   case object NullType extends Type
 
-  /** Reference types (allowed for classOf[], is/asInstanceOf[]). */
-  sealed abstract class ReferenceType extends Type
+  /** Reference types (allowed for classOf[], is/asInstanceOf[]).
+   *
+   *  A `ReferenceType` has exactly the same level of precision as a JVM type.
+   *  There is a one-to-one relationship between a `ReferenceType` and an
+   *  instance of `java.lang.Class` at run-time. This means that:
+   *
+   *  - All primitive types have their reference type (including `scala.Byte`
+   *    and `scala.Short`), and they are different from their boxed versions.
+   *  - Raw JS types are not erased to `any`
+   *  - Array types are like on the JVM
+   *
+   *  A `ReferenceType` therefore uniquely identifies a `classOf[T]`. It is
+   *  also the reference types that are used in method signatures, and which
+   *  therefore dictate JVM/IR overloading.
+   */
+  sealed trait ReferenceType
 
   /** Class (or interface) type. */
-  final case class ClassType(className: String) extends ReferenceType
+  final case class ClassType(className: String) extends Type with ReferenceType
 
   /** Array type. */
-  final case class ArrayType(baseClassName: String, dimensions: Int) extends ReferenceType
+  final case class ArrayType(baseClassName: String, dimensions: Int)
+      extends Type with ReferenceType
 
   object ArrayType {
     def apply(innerType: ReferenceType): ArrayType = innerType match {

tools/shared/src/main/scala/org/scalajs/core/tools/optimizer/IRChecker.scala

@@ -881,7 +881,7 @@ class IRChecker(unit: LinkingUnit, logger: Logger) {
 
   def refTypeToType(refType: ReferenceType)(implicit ctx: ErrorContext): Type = {
     refType match {
-      case _: ArrayType           => refType
+      case arrayType: ArrayType   => arrayType
       case ClassType(encodedName) => classNameToType(encodedName)
     }
   }

tools/shared/src/main/scala/org/scalajs/core/tools/optimizer/OptimizerCore.scala

@@ -482,7 +482,8 @@ private[optimizer] abstract class OptimizerCore(
         trampoline {
           pretransformExpr(expr) { texpr =>
             val result = {
-              if (isSubtype(texpr.tpe.base, tpe)) {
+              // TODO This cast is suspicious
+              if (isSubtype(texpr.tpe.base, tpe.asInstanceOf[Type])) {
                 if (texpr.tpe.isNullable)
                   BinaryOp(BinaryOp.!==, finishTransformExpr(texpr), Null())
                 else
@@ -824,7 +825,8 @@ private[optimizer] abstract class OptimizerCore(
             case ClassType(ObjectClass) =>
               cont(texpr)
             case _ =>
-              if (isSubtype(texpr.tpe.base, tpe)) {
+              // TODO This cast is suspicious
+              if (isSubtype(texpr.tpe.base, tpe.asInstanceOf[Type])) {
                 cont(texpr)
               } else {
                 cont(PreTransTree(