Fix #5135: Move well-known names to a new object WellKnownNames.

This breaks the circular dependency between the initialization of
`object Types` and `object Names`.

Author: sjrd

compiler/src/main/scala/org/scalajs/nscplugin/GenJSCode.scala

@@ -26,16 +26,22 @@ import scala.annotation.tailrec
 import scala.reflect.internal.Flags
 
 import org.scalajs.ir
-import org.scalajs.ir.{Trees => js, Types => jstpe, ClassKind, Hashers, OriginalName}
+import org.scalajs.ir.{
+  Trees => js,
+  Types => jstpe,
+  WellKnownNames => jswkn,
+  ClassKind,
+  Hashers,
+  OriginalName
+}
 import org.scalajs.ir.Names.{
   LocalName,
   LabelName,
   SimpleFieldName,
   FieldName,
   SimpleMethodName,
   MethodName,
-  ClassName,
-  BoxedStringClass
+  ClassName
 }
 import org.scalajs.ir.OriginalName.NoOriginalName
 import org.scalajs.ir.Trees.OptimizerHints
@@ -168,7 +174,7 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
     def currentThisType: jstpe.Type = {
       currentThisTypeNullable match {
         case tpe @ jstpe.ClassType(cls, _) =>
-          jstpe.BoxedClassToPrimType.getOrElse(cls, tpe.toNonNullable)
+          jswkn.BoxedClassToPrimType.getOrElse(cls, tpe.toNonNullable)
         case tpe @ jstpe.AnyType =>
           // We are in a JS class, in which even `this` is nullable
           tpe
@@ -692,7 +698,7 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
           reflectInit.toList ::: staticModuleInit.toList
         if (staticInitializerStats.nonEmpty) {
           List(genStaticConstructorWithStats(
-              ir.Names.StaticInitializerName,
+              jswkn.StaticInitializerName,
               js.Block(staticInitializerStats)))
         } else {
           Nil
@@ -723,7 +729,7 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
                   originalName,
                   ClassKind.Class,
                   None,
-                  Some(js.ClassIdent(ir.Names.ObjectClass)),
+                  Some(js.ClassIdent(jswkn.ObjectClass)),
                   Nil,
                   None,
                   None,
@@ -838,7 +844,7 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
 
           if (staticFields.nonEmpty) {
             generatedMethods += genStaticConstructorWithStats(
-                ir.Names.ClassInitializerName, genLoadModule(companionModuleClass))
+                jswkn.ClassInitializerName, genLoadModule(companionModuleClass))
           }
 
           (staticFields, staticExports)
@@ -943,7 +949,7 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
       // Make new class def with static members
       val newClassDef = {
         implicit val pos = origJsClass.pos
-        val parent = js.ClassIdent(ir.Names.ObjectClass)
+        val parent = js.ClassIdent(jswkn.ObjectClass)
         js.ClassDef(origJsClass.name, origJsClass.originalName,
             ClassKind.AbstractJSType, None, Some(parent), interfaces = Nil,
             jsSuperClass = None, jsNativeLoadSpec = None, fields = Nil,
@@ -5438,8 +5444,8 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
           // LinkingInfo.linkTimePropertyXXX("...")
           val arg = genArgs1
           val tpe: jstpe.Type = toIRType(tree.tpe) match {
-            case jstpe.ClassType(BoxedStringClass, _) => jstpe.StringType
-            case irType                               => irType
+            case jstpe.ClassType(jswkn.BoxedStringClass, _) => jstpe.StringType
+            case irType                                     => irType
           }
           arg match {
             case js.StringLiteral(name) =>
@@ -6431,8 +6437,8 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
                     fParamDef.ref),
                 js.ApplyStatically(js.ApplyFlags.empty.withConstructor(true),
                     js.This()(thisType),
-                    ir.Names.ObjectClass,
-                    js.MethodIdent(ir.Names.NoArgConstructorName),
+                    jswkn.ObjectClass,
+                    js.MethodIdent(jswkn.NoArgConstructorName),
                     Nil)(jstpe.VoidType)))))(
             js.OptimizerHints.empty, Unversioned)
       }
@@ -6491,7 +6497,7 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
           NoOriginalName,
           ClassKind.Class,
           None,
-          Some(js.ClassIdent(ir.Names.ObjectClass)),
+          Some(js.ClassIdent(jswkn.ObjectClass)),
           List(js.ClassIdent(intfName)),
           None,
           None,
@@ -7133,37 +7139,37 @@ private object GenJSCode {
   private val newSimpleMethodName = SimpleMethodName("new")
 
   private val ObjectArgConstructorName =
-    MethodName.constructor(List(jstpe.ClassRef(ir.Names.ObjectClass)))
+    MethodName.constructor(List(jswkn.ObjectRef))
 
   private val lengthMethodName =
     MethodName("length", Nil, jstpe.IntRef)
   private val charAtMethodName =
     MethodName("charAt", List(jstpe.IntRef), jstpe.CharRef)
 
   private val getNameMethodName =
-    MethodName("getName", Nil, jstpe.ClassRef(ir.Names.BoxedStringClass))
+    MethodName("getName", Nil, jstpe.ClassRef(jswkn.BoxedStringClass))
   private val isPrimitiveMethodName =
     MethodName("isPrimitive", Nil, jstpe.BooleanRef)
   private val isInterfaceMethodName =
     MethodName("isInterface", Nil, jstpe.BooleanRef)
   private val isArrayMethodName =
     MethodName("isArray", Nil, jstpe.BooleanRef)
   private val getComponentTypeMethodName =
-    MethodName("getComponentType", Nil, jstpe.ClassRef(ir.Names.ClassClass))
+    MethodName("getComponentType", Nil, jstpe.ClassRef(jswkn.ClassClass))
   private val getSuperclassMethodName =
-    MethodName("getSuperclass", Nil, jstpe.ClassRef(ir.Names.ClassClass))
+    MethodName("getSuperclass", Nil, jstpe.ClassRef(jswkn.ClassClass))
 
   private val isInstanceMethodName =
-    MethodName("isInstance", List(jstpe.ClassRef(ir.Names.ObjectClass)), jstpe.BooleanRef)
+    MethodName("isInstance", List(jstpe.ClassRef(jswkn.ObjectClass)), jstpe.BooleanRef)
   private val isAssignableFromMethodName =
-    MethodName("isAssignableFrom", List(jstpe.ClassRef(ir.Names.ClassClass)), jstpe.BooleanRef)
+    MethodName("isAssignableFrom", List(jstpe.ClassRef(jswkn.ClassClass)), jstpe.BooleanRef)
   private val castMethodName =
-    MethodName("cast", List(jstpe.ClassRef(ir.Names.ObjectClass)), jstpe.ClassRef(ir.Names.ObjectClass))
+    MethodName("cast", List(jstpe.ClassRef(jswkn.ObjectClass)), jstpe.ClassRef(jswkn.ObjectClass))
 
   private val arrayNewInstanceMethodName = {
     MethodName("newInstance",
-        List(jstpe.ClassRef(ir.Names.ClassClass), jstpe.IntRef),
-        jstpe.ClassRef(ir.Names.ObjectClass))
+        List(jstpe.ClassRef(jswkn.ClassClass), jstpe.IntRef),
+        jstpe.ClassRef(jswkn.ObjectClass))
   }
 
   private val thisOriginalName = OriginalName("this")

compiler/src/main/scala/org/scalajs/nscplugin/GenJSExports.scala

@@ -20,7 +20,7 @@ import scala.reflect.{ClassTag, classTag}
 import scala.reflect.internal.Flags
 
 import org.scalajs.ir
-import org.scalajs.ir.{Trees => js, Types => jstpe}
+import org.scalajs.ir.{Trees => js, Types => jstpe, WellKnownNames => jswkn}
 import org.scalajs.ir.Names.LocalName
 import org.scalajs.ir.OriginalName.NoOriginalName
 import org.scalajs.ir.Trees.OptimizerHints
@@ -970,8 +970,6 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
         InstanceOfTypeTest(tpe.valueClazz.typeConstructor)
 
       case _ =>
-        import org.scalajs.ir.Names
-
         (toIRType(tpe): @unchecked) match {
           case jstpe.AnyType | jstpe.AnyNotNullType => NoTypeTest
 
@@ -985,8 +983,8 @@ trait GenJSExports[G <: Global with Singleton] extends SubComponent {
           case jstpe.FloatType   => PrimitiveTypeTest(jstpe.FloatType, 7)
           case jstpe.DoubleType  => PrimitiveTypeTest(jstpe.DoubleType, 8)
 
-          case jstpe.ClassType(Names.BoxedUnitClass, _)   => PrimitiveTypeTest(jstpe.UndefType, 0)
-          case jstpe.ClassType(Names.BoxedStringClass, _) => PrimitiveTypeTest(jstpe.StringType, 9)
+          case jstpe.ClassType(jswkn.BoxedUnitClass, _)   => PrimitiveTypeTest(jstpe.UndefType, 0)
+          case jstpe.ClassType(jswkn.BoxedStringClass, _) => PrimitiveTypeTest(jstpe.StringType, 9)
           case jstpe.ClassType(_, _)                      => InstanceOfTypeTest(tpe)
 
           case jstpe.ArrayType(_, _) => InstanceOfTypeTest(tpe)

compiler/src/main/scala/org/scalajs/nscplugin/JSEncoding.scala

@@ -17,7 +17,7 @@ import scala.collection.mutable
 import scala.tools.nsc._
 
 import org.scalajs.ir
-import org.scalajs.ir.{Trees => js, Types => jstpe}
+import org.scalajs.ir.{Trees => js, Types => jstpe, WellKnownNames => jswkn}
 import org.scalajs.ir.Names.{LocalName, LabelName, SimpleFieldName, FieldName, SimpleMethodName, MethodName, ClassName}
 import org.scalajs.ir.OriginalName
 import org.scalajs.ir.OriginalName.NoOriginalName
@@ -237,7 +237,7 @@ trait JSEncoding[G <: Global with Singleton] extends SubComponent {
   def encodeDynamicImportForwarderIdent(params: List[Symbol])(
       implicit pos: Position): js.MethodIdent = {
     val paramTypeRefs = params.map(sym => paramOrResultTypeRef(sym.tpe))
-    val resultTypeRef = jstpe.ClassRef(ir.Names.ObjectClass)
+    val resultTypeRef = jstpe.ClassRef(jswkn.ObjectClass)
     val methodName =
       MethodName(dynamicImportForwarderSimpleName, paramTypeRefs, resultTypeRef)
 
@@ -288,13 +288,13 @@ trait JSEncoding[G <: Global with Singleton] extends SubComponent {
     assert(!sym.isPrimitiveValueClass,
         s"Illegal encodeClassName(${sym.fullName}")
     if (sym == jsDefinitions.HackedStringClass) {
-      ir.Names.BoxedStringClass
+      jswkn.BoxedStringClass
     } else if (sym == jsDefinitions.HackedStringModClass) {
       BoxedStringModuleClassName
     } else if (sym == definitions.BoxedUnitClass || sym == jsDefinitions.BoxedUnitModClass) {
       // Rewire scala.runtime.BoxedUnit to java.lang.Void, as the IR expects
       // BoxedUnit$ is a JVM artifact
-      ir.Names.BoxedUnitClass
+      jswkn.BoxedUnitClass
     } else {
       ClassName(sym.fullName + (if (needsModuleClassSuffix(sym)) "$" else ""))
     }

compiler/src/main/scala/org/scalajs/nscplugin/PrepJSExports.scala

@@ -16,8 +16,8 @@ import scala.collection.mutable
 
 import scala.tools.nsc.Global
 
-import org.scalajs.ir.Names.DefaultModuleID
 import org.scalajs.ir.Trees.TopLevelExportDef.isValidTopLevelExportName
+import org.scalajs.ir.WellKnownNames.DefaultModuleID
 
 /**
  *  Prepare export generation

ir/shared/src/main/scala/org/scalajs/ir/Names.scala

@@ -471,21 +471,25 @@ object Names {
   }
 
   object MethodName {
-    private val ReflectiveProxyResultTypeRef = ClassRef(ObjectClass)
-    private final val ReflectiveProxyResultTypeName = "java.lang.Object"
-
     def apply(simpleName: SimpleMethodName, paramTypeRefs: List[TypeRef],
         resultTypeRef: TypeRef, isReflectiveProxy: Boolean): MethodName = {
       if ((simpleName.isConstructor || simpleName.isStaticInitializer ||
           simpleName.isClassInitializer) && resultTypeRef != VoidRef) {
         throw new IllegalArgumentException(
             "A constructor or static initializer must have a void result type")
       }
-      if (isReflectiveProxy && resultTypeRef != ReflectiveProxyResultTypeRef) {
-        throw new IllegalArgumentException(
-            "A reflective proxy must have a result type of " +
-            ReflectiveProxyResultTypeName)
+
+      if (isReflectiveProxy) {
+        /* It is fine to use WellKnownNames here because nothing in `Names`
+         * nor `Types` ever creates a reflective proxy name. So this code path
+         * is not reached during their initialization.
+         */
+        if (resultTypeRef != WellKnownNames.ObjectRef) {
+          throw new IllegalArgumentException(
+              "A reflective proxy must have a result type of java.lang.Object")
+        }
       }
+
       new MethodName(simpleName, paramTypeRefs, resultTypeRef,
           isReflectiveProxy)
     }
@@ -509,7 +513,11 @@ object Names {
 
     def reflectiveProxy(simpleName: SimpleMethodName,
         paramTypeRefs: List[TypeRef]): MethodName = {
-      apply(simpleName, paramTypeRefs, ReflectiveProxyResultTypeRef,
+      /* It is fine to use WellKnownNames here because nothing in `Names`
+       * nor `Types` ever creates a reflective proxy name. So this code path
+       * is not reached during their initialization.
+       */
+      apply(simpleName, paramTypeRefs, WellKnownNames.ObjectRef,
           isReflectiveProxy = true)
     }
 
@@ -553,121 +561,6 @@ object Names {
 
   // scalastyle:on equals.hash.code
 
-  /** `java.lang.Object`, the root of the class hierarchy. */
-  val ObjectClass: ClassName = ClassName("java.lang.Object")
-
-  // Hijacked classes
-  val BoxedUnitClass: ClassName = ClassName("java.lang.Void")
-  val BoxedBooleanClass: ClassName = ClassName("java.lang.Boolean")
-  val BoxedCharacterClass: ClassName = ClassName("java.lang.Character")
-  val BoxedByteClass: ClassName = ClassName("java.lang.Byte")
-  val BoxedShortClass: ClassName = ClassName("java.lang.Short")
-  val BoxedIntegerClass: ClassName = ClassName("java.lang.Integer")
-  val BoxedLongClass: ClassName = ClassName("java.lang.Long")
-  val BoxedFloatClass: ClassName = ClassName("java.lang.Float")
-  val BoxedDoubleClass: ClassName = ClassName("java.lang.Double")
-  val BoxedStringClass: ClassName = ClassName("java.lang.String")
-
-  /** The set of all hijacked classes. */
-  val HijackedClasses: Set[ClassName] = Set(
-      BoxedUnitClass,
-      BoxedBooleanClass,
-      BoxedCharacterClass,
-      BoxedByteClass,
-      BoxedShortClass,
-      BoxedIntegerClass,
-      BoxedLongClass,
-      BoxedFloatClass,
-      BoxedDoubleClass,
-      BoxedStringClass
-  )
-
-  /** The class of things returned by `ClassOf` and `GetClass`. */
-  val ClassClass: ClassName = ClassName("java.lang.Class")
-
-  /** `java.lang.Cloneable`, which is an ancestor of array classes and is used
-   *  by `Clone`.
-   */
-  val CloneableClass: ClassName = ClassName("java.lang.Cloneable")
-
-  /** `java.io.Serializable`, which is an ancestor of array classes. */
-  val SerializableClass: ClassName = ClassName("java.io.Serializable")
-
-  /** The superclass of all throwables.
-   *
-   *  This is the result type of `WrapAsThrowable` nodes, as well as the input
-   *  type of `UnwrapFromThrowable`.
-   */
-  val ThrowableClass = ClassName("java.lang.Throwable")
-
-  /** The exception thrown by a division by 0. */
-  val ArithmeticExceptionClass: ClassName =
-    ClassName("java.lang.ArithmeticException")
-
-  /** The exception thrown by an `ArraySelect` that is out of bounds. */
-  val ArrayIndexOutOfBoundsExceptionClass: ClassName =
-    ClassName("java.lang.ArrayIndexOutOfBoundsException")
-
-  /** The exception thrown by an `Assign(ArraySelect, ...)` where the value cannot be stored. */
-  val ArrayStoreExceptionClass: ClassName =
-    ClassName("java.lang.ArrayStoreException")
-
-  /** The exception thrown by a `NewArray(...)` with a negative size. */
-  val NegativeArraySizeExceptionClass: ClassName =
-    ClassName("java.lang.NegativeArraySizeException")
-
-  /** The exception thrown by a variety of nodes for `null` arguments.
-   *
-   *  - `Apply` and `ApplyStatically` for the receiver,
-   *  - `Select` for the qualifier,
-   *  - `ArrayLength` and `ArraySelect` for the array,
-   *  - `GetClass`, `Clone` and `UnwrapFromException` for their respective only arguments.
-   */
-  val NullPointerExceptionClass: ClassName =
-    ClassName("java.lang.NullPointerException")
-
-  /** The exception thrown by a `BinaryOp.String_charAt` that is out of bounds. */
-  val StringIndexOutOfBoundsExceptionClass: ClassName =
-    ClassName("java.lang.StringIndexOutOfBoundsException")
-
-  /** The exception thrown by an `AsInstanceOf` that fails. */
-  val ClassCastExceptionClass: ClassName =
-    ClassName("java.lang.ClassCastException")
-
-  /** The exception thrown by a `Class_newArray` if the first argument is `classOf[Unit]`. */
-  val IllegalArgumentExceptionClass: ClassName =
-    ClassName("java.lang.IllegalArgumentException")
-
-  /** The set of classes and interfaces that are ancestors of array classes. */
-  private[ir] val AncestorsOfPseudoArrayClass: Set[ClassName] = {
-    /* This would logically be defined in Types, but that introduces a cyclic
-     * dependency between the initialization of Names and Types.
-     */
-    Set(ObjectClass, CloneableClass, SerializableClass)
-  }
-
-  /** Name of a constructor without argument.
-   *
-   *  This is notably the signature of constructors of module classes.
-   */
-  final val NoArgConstructorName: MethodName =
-    MethodName.constructor(Nil)
-
-  /** This is used to construct a java.lang.Class. */
-  final val ObjectArgConstructorName: MethodName =
-    MethodName.constructor(List(ClassRef(ObjectClass)))
-
-  /** Name of the static initializer method. */
-  final val StaticInitializerName: MethodName =
-    MethodName(SimpleMethodName.StaticInitializer, Nil, VoidRef)
-
-  /** Name of the class initializer method. */
-  final val ClassInitializerName: MethodName =
-    MethodName(SimpleMethodName.ClassInitializer, Nil, VoidRef)
-
-  /** ModuleID of the default module */
-  final val DefaultModuleID: String = "main"
-
   // ---------------------------------------------------
   // ----- Private helpers for validation of names -----
   // ---------------------------------------------------

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

@@ -29,6 +29,7 @@ import LinkTimeProperty.{ProductionMode, ESVersion, UseECMAScript2015Semantics,
 import Types._
 import Tags._
 import Version.Unversioned
+import WellKnownNames._
 
 import Utils.JumpBackByteArrayOutputStream