First versions of Definitions based on TypeRefs not Symbols.

Symbols are not stable between runs, so if some symbol referred
to from Definitions gets recompiled, there are then two Symbols
that are both visible, one referenced from Definitions, the other
the one that got compiled.

Thos led to a crash when e.g. compiling scala.Short, because the
newly compiled symbol was not recognized as a primitive value
class.

The present commit tries to make systematic changes without regard
to simplicity or aesthetics. This will be polished in future commits.
// ### comments signal areas that need further attention.

2 files changed, 33 insertions, 36 deletions

diff --git a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index f92abe906..6c737f58f 100644
--- a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -99,9 +99,6 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
   val nme_PACKAGE: Name = StdNames.nme.PACKAGE
   val nme_EQEQ_LOCAL_VAR: Name = StdNames.nme.EQEQ_LOCAL_VAR
 
-  val BoxesRunTimeModule     = ctx.requiredModule("scala.runtime.BoxesRunTime")
-  val BoxesRunTimeClass      = toDenot(BoxesRunTimeModule).moduleClass.asClass
-
    // require LambdaMetafactory: scalac uses getClassIfDefined, but we need those always.
   override lazy val LambdaMetaFactory = ctx.requiredClass("java.lang.invoke.LambdaMetafactory")
   override lazy val MethodHandle      = ctx.requiredClass("java.lang.invoke.MethodHandle")
@@ -133,17 +130,17 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
   }
 
   val hashMethodSym: Symbol = NoSymbol // used to dispatch ## on primitives to ScalaRuntime.hash. Should be implemented by a miniphase
-  val externalEqualsNumNum: Symbol = ctx.requiredMethod(BoxesRunTimeClass, nme.equalsNumNum)
-  lazy val externalEqualsNumChar: Symbol = ??? // ctx.requiredMethod(BoxesRunTimeClass, nme.equalsNumChar) // this method is private
-  val externalEqualsNumObject: Symbol = ctx.requiredMethod(BoxesRunTimeClass, nme.equalsNumObject)
-  val externalEquals: Symbol = BoxesRunTimeClass.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol
+  val externalEqualsNumNum: Symbol = ctx.requiredMethod(defn.BoxesRunTimeModuleRef, nme.equalsNumNum)
+  lazy val externalEqualsNumChar: Symbol = ??? // ctx.requiredMethod(BoxesRunTimeTypeRef, nme.equalsNumChar) // this method is private
+  val externalEqualsNumObject: Symbol = ctx.requiredMethod(defn.BoxesRunTimeModuleRef, nme.equalsNumObject)
+  val externalEquals: Symbol = defn.BoxesRunTimeClass.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol
   val MaxFunctionArity: Int = Definitions.MaxFunctionArity
   val FunctionClass: Array[Symbol] = defn.FunctionClass.asInstanceOf[Array[Symbol]]
   val AbstractFunctionClass: Array[Symbol] = defn.AbstractFunctionClass.asInstanceOf[Array[Symbol]]
   val PartialFunctionClass: Symbol = defn.PartialFunctionClass
   val AbstractPartialFunctionClass: Symbol = defn.AbstractPartialFunctionClass
   val String_valueOf: Symbol = defn.String_valueOf_Object
-  lazy val Predef_classOf: Symbol = ctx.requiredMethod(toDenot(defn.ScalaPredefModule).moduleClass.asClass, nme.classOf)
+  lazy val Predef_classOf: Symbol = ctx.requiredMethod(defn.ScalaPredefModuleRef, nme.classOf)
 
   lazy val AnnotationRetentionAttr = ctx.requiredClass("java.lang.annotation.Retention")
   lazy val AnnotationRetentionSourceAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE")
diff --git a/src/dotty/tools/backend/jvm/scalaPrimitives.scala b/src/dotty/tools/backend/jvm/scalaPrimitives.scala
index 8e742faf1..afcf06da1 100644
--- a/src/dotty/tools/backend/jvm/scalaPrimitives.scala
+++ b/src/dotty/tools/backend/jvm/scalaPrimitives.scala
@@ -78,42 +78,42 @@ class DottyPrimitives(ctx: Context) {
 
     code match {
 
-      case APPLY =>
-        elementType.classSymbol match {
-          case defn.BooleanClass    => ZARRAY_GET
-          case defn.ByteClass       => BARRAY_GET
-          case defn.ShortClass      => SARRAY_GET
-          case defn.CharClass       => CARRAY_GET
-          case defn.IntClass        => IARRAY_GET
-          case defn.LongClass       => LARRAY_GET
-          case defn.FloatClass      => FARRAY_GET
-          case defn.DoubleClass     => DARRAY_GET
+      case APPLY => // ### unstable, use names?
+        elementType match {
+          case defn.BooleanTypeRef    => ZARRAY_GET
+          case defn.ByteTypeRef       => BARRAY_GET
+          case defn.ShortTypeRef      => SARRAY_GET
+          case defn.CharTypeRef       => CARRAY_GET
+          case defn.IntTypeRef        => IARRAY_GET
+          case defn.LongTypeRef       => LARRAY_GET
+          case defn.FloatTypeRef      => FARRAY_GET
+          case defn.DoubleTypeRef     => DARRAY_GET
           case _                    => OARRAY_GET
         }
 
       case UPDATE =>
-        elementType.classSymbol match {
-          case defn.BooleanClass    => ZARRAY_SET
-          case defn.ByteClass       => BARRAY_SET
-          case defn.ShortClass      => SARRAY_SET
-          case defn.CharClass       => CARRAY_SET
-          case defn.IntClass        => IARRAY_SET
-          case defn.LongClass       => LARRAY_SET
-          case defn.FloatClass      => FARRAY_SET
-          case defn.DoubleClass     => DARRAY_SET
+        elementType match {
+          case defn.BooleanTypeRef    => ZARRAY_SET
+          case defn.ByteTypeRef       => BARRAY_SET
+          case defn.ShortTypeRef      => SARRAY_SET
+          case defn.CharTypeRef       => CARRAY_SET
+          case defn.IntTypeRef        => IARRAY_SET
+          case defn.LongTypeRef       => LARRAY_SET
+          case defn.FloatTypeRef      => FARRAY_SET
+          case defn.DoubleTypeRef     => DARRAY_SET
           case _                    => OARRAY_SET
         }
 
       case LENGTH =>
-        elementType.classSymbol match {
-          case defn.BooleanClass    => ZARRAY_LENGTH
-          case defn.ByteClass       => BARRAY_LENGTH
-          case defn.ShortClass      => SARRAY_LENGTH
-          case defn.CharClass       => CARRAY_LENGTH
-          case defn.IntClass        => IARRAY_LENGTH
-          case defn.LongClass       => LARRAY_LENGTH
-          case defn.FloatClass      => FARRAY_LENGTH
-          case defn.DoubleClass     => DARRAY_LENGTH
+        elementType match {
+          case defn.BooleanTypeRef    => ZARRAY_LENGTH
+          case defn.ByteTypeRef       => BARRAY_LENGTH
+          case defn.ShortTypeRef      => SARRAY_LENGTH
+          case defn.CharTypeRef       => CARRAY_LENGTH
+          case defn.IntTypeRef        => IARRAY_LENGTH
+          case defn.LongTypeRef       => LARRAY_LENGTH
+          case defn.FloatTypeRef      => FARRAY_LENGTH
+          case defn.DoubleTypeRef     => DARRAY_LENGTH
           case _                    => OARRAY_LENGTH
         }