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.

1 files changed, 336 insertions, 208 deletions

diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala
index 6f322904e..fc025380d 100644
--- a/src/dotty/tools/dotc/core/Definitions.scala
+++ b/src/dotty/tools/dotc/core/Definitions.scala
@@ -82,9 +82,9 @@ class Definitions {
   private def newT1EmptyParamsMethod(cls: ClassSymbol, name: TermName, resultTypeFn: PolyType => Type, flags: FlagSet) =
     newPolyMethod(cls, name, 1, pt => MethodType(Nil, resultTypeFn(pt)), flags)
 
-  private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[ClassSymbol] = {
-    val arr = new Array[ClassSymbol](arity + 1)
-    for (i <- countFrom to arity) arr(i) = ctx.requiredClass(name + i)
+  private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[TypeRef] = {
+    val arr = new Array[TypeRef](arity + 1)
+    for (i <- countFrom to arity) arr(i) = ctx.requiredClassRef(name + i)
     arr
   }
 
@@ -114,7 +114,8 @@ class Definitions {
   lazy val JavaLangPackageVal = ctx.requiredPackage("java.lang")
   // fundamental modules
   lazy val SysPackage = ctx.requiredModule("scala.sys.package")
-    def Sys_error = ctx.requiredMethod(SysPackage.moduleClass.asClass, nme.error)
+    lazy val Sys_errorR = ctx.requiredMethodRef(SysPackage.moduleClass.typeRef, nme.error)
+    def Sys_error = Sys_errorR.symbol
 
   /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter)
    *  because after erasure the Any and AnyVal references get remapped to the Object methods
@@ -160,6 +161,7 @@ class Definitions {
     cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope)
     completeClass(cls)
   }
+
   lazy val AnyRefAlias: TypeSymbol = newAliasType(tpnme.AnyRef, ObjectType)
 
     lazy val Object_eq = newMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
@@ -190,29 +192,41 @@ class Definitions {
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
   lazy val NullClass: ClassSymbol = newCompleteClassSymbol(
     ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef))
+  lazy val NullTypeRef = NullClass.typeRef
 
-  lazy val ScalaPredefModule = ctx.requiredModule("scala.Predef")
+  lazy val ScalaPredefModuleRef = ctx.requiredModuleRef("scala.Predef")
+  def ScalaPredefModule = ScalaPredefModuleRef.symbol
 
-    lazy val Predef_conforms = ctx.requiredMethod(ScalaPredefModule.moduleClass.asClass, "$conforms")
+    lazy val Predef_conformsR = ctx.requiredMethodRef(ScalaPredefModuleRef, "$conforms")
+    def Predef_conforms = Predef_conformsR.symbol
 
-  lazy val ScalaRuntimeModule = ctx.requiredModule("scala.runtime.ScalaRunTime")
-  lazy val ScalaRuntimeClass = ScalaRuntimeModule.moduleClass.asClass
+  lazy val ScalaRuntimeModuleRef = ctx.requiredModuleRef("scala.runtime.ScalaRunTime")
+  def ScalaRuntimeModule = ScalaRuntimeModuleRef.symbol
+  def ScalaRuntimeClass = ScalaRuntimeModule.moduleClass.asClass
 
-    def runtimeMethod(name: PreName) = ctx.requiredMethod(ScalaRuntimeClass, name)
+    def runtimeMethodRef(name: PreName) = ctx.requiredMethodRef(ScalaRuntimeModuleRef, name)
+    def ScalaRuntime_dropR = runtimeMethodRef(nme.drop)
+    def ScalaRuntime_drop = ScalaRuntime_dropR.symbol
 
-  lazy val BoxesRunTimeModule = ctx.requiredModule("scala.runtime.BoxesRunTime")
-  lazy val BoxesRunTimeClass = BoxesRunTimeModule.moduleClass.asClass
-  lazy val ScalaStaticsModule = ctx.requiredModule("scala.runtime.Statics")
-  lazy val ScalaStaticsClass = ScalaStaticsModule.moduleClass.asClass
+  lazy val BoxesRunTimeModuleRef = ctx.requiredModuleRef("scala.runtime.BoxesRunTime")
+  def BoxesRunTimeModule = BoxesRunTimeModuleRef.symbol
+  def BoxesRunTimeClass = BoxesRunTimeModule.moduleClass.asClass
+  lazy val ScalaStaticsModuleRef = ctx.requiredModuleRef("scala.runtime.Statics")
+  def ScalaStaticsModule = ScalaStaticsModuleRef.symbol
+  def ScalaStaticsClass = ScalaStaticsModule.moduleClass.asClass
 
-    def staticsMethod(name: PreName) = ctx.requiredMethod(ScalaStaticsClass, name)
+    def staticsMethodRef(name: PreName) = ctx.requiredMethodRef(ScalaStaticsModuleRef, name)
+    def staticsMethod(name: PreName) = ctx.requiredMethod(ScalaStaticsModuleRef, name)
 
-  lazy val DottyPredefModule = ctx.requiredModule("dotty.DottyPredef")
-  lazy val DottyArraysModule = ctx.requiredModule("dotty.runtime.Arrays")
+  lazy val DottyPredefModuleRef = ctx.requiredModuleRef("dotty.DottyPredef")
+  def DottyPredefModule = DottyPredefModuleRef.symbol
+  lazy val DottyArraysModuleRef = ctx.requiredModuleRef("dotty.runtime.Arrays")
+  def DottyArraysModule = DottyArraysModuleRef.symbol
 
-    def newRefArrayMethod = ctx.requiredMethod(DottyArraysModule.moduleClass.asClass, "newRefArray")
+    def newRefArrayMethod = ctx.requiredMethod(DottyArraysModuleRef, "newRefArray")
 
-  lazy val NilModule = ctx.requiredModule("scala.collection.immutable.Nil")
+  lazy val NilModuleRef = ctx.requiredModuleRef("scala.collection.immutable.Nil")
+  def NilModule = NilModuleRef.symbol
 
 //  lazy val FunctionClass: ClassSymbol = ctx.requiredClass("scala.Function")
   lazy val SingletonClass: ClassSymbol =
@@ -221,57 +235,96 @@ class Definitions {
     newCompleteClassSymbol(
       ScalaPackageClass, tpnme.Singleton, PureInterfaceCreationFlags | Final,
       List(AnyClass.typeRef), EmptyScope)
-  lazy val SeqClass: ClassSymbol = ctx.requiredClass("scala.collection.Seq")
-    lazy val Seq_apply = ctx.requiredMethod(SeqClass, nme.apply)
-    lazy val Seq_head = ctx.requiredMethod(SeqClass, nme.head)
-  lazy val ArrayClass: ClassSymbol = ctx.requiredClass("scala.Array")
-    lazy val Array_apply                 = ctx.requiredMethod(ArrayClass, nme.apply)
-    lazy val Array_update                = ctx.requiredMethod(ArrayClass, nme.update)
-    lazy val Array_length                = ctx.requiredMethod(ArrayClass, nme.length)
-    lazy val Array_clone                 = ctx.requiredMethod(ArrayClass, nme.clone_)
-    lazy val ArrayConstructor            = ctx.requiredMethod(ArrayClass, nme.CONSTRUCTOR)
-  lazy val traversableDropMethod  = ctx.requiredMethod(ScalaRuntimeClass, nme.drop)
-  lazy val uncheckedStableClass: ClassSymbol = ctx.requiredClass("scala.annotation.unchecked.uncheckedStable")
-
-  lazy val UnitClass = valueClassSymbol("scala.Unit", BoxedUnitClass, java.lang.Void.TYPE, UnitEnc)
-  lazy val BooleanClass = valueClassSymbol("scala.Boolean", BoxedBooleanClass, java.lang.Boolean.TYPE, BooleanEnc)
-    lazy val Boolean_!   = BooleanClass.requiredMethod(nme.UNARY_!)
-    lazy val Boolean_&& = BooleanClass.requiredMethod(nme.ZAND)
-    lazy val Boolean_||  = BooleanClass.requiredMethod(nme.ZOR)
-
-  lazy val ByteClass = valueClassSymbol("scala.Byte", BoxedByteClass, java.lang.Byte.TYPE, ByteEnc)
-  lazy val ShortClass = valueClassSymbol("scala.Short", BoxedShortClass, java.lang.Short.TYPE, ShortEnc)
-  lazy val CharClass = valueClassSymbol("scala.Char", BoxedCharClass, java.lang.Character.TYPE, CharEnc)
-  lazy val IntClass = valueClassSymbol("scala.Int", BoxedIntClass, java.lang.Integer.TYPE, IntEnc)
-    lazy val Int_-   = IntClass.requiredMethod(nme.MINUS, List(IntType))
-    lazy val Int_+   = IntClass.requiredMethod(nme.PLUS, List(IntType))
-    lazy val Int_/   = IntClass.requiredMethod(nme.DIV, List(IntType))
-    lazy val Int_*   = IntClass.requiredMethod(nme.MUL, List(IntType))
-    lazy val Int_==   = IntClass.requiredMethod(nme.EQ, List(IntType))
-    lazy val Int_>=   = IntClass.requiredMethod(nme.GE, List(IntType))
-    lazy val Int_<=   = IntClass.requiredMethod(nme.LE, List(IntType))
-  lazy val LongClass = valueClassSymbol("scala.Long", BoxedLongClass, java.lang.Long.TYPE, LongEnc)
-    lazy val Long_XOR_Long = LongClass.info.member(nme.XOR).requiredSymbol(
+
+  lazy val SeqTypeRef = ctx.requiredClassRef("scala.collection.Seq")
+  def SeqClass = SeqTypeRef.symbol.asClass
+    lazy val Seq_applyR = ctx.requiredMethodRef(SeqTypeRef, nme.apply)
+    def Seq_apply = Seq_applyR.symbol
+    lazy val Seq_headR = ctx.requiredMethodRef(SeqTypeRef, nme.head)
+    def Seq_head = Seq_headR.symbol
+
+  lazy val ArrayTypeRef = ctx.requiredClassRef("scala.Array")
+  def ArrayClass = ArrayTypeRef.symbol.asClass
+    lazy val Array_applyR                 = ctx.requiredMethodRef(ArrayTypeRef, nme.apply)
+    def Array_apply = Array_applyR.symbol
+    lazy val Array_updateR                = ctx.requiredMethodRef(ArrayTypeRef, nme.update)
+    def Array_update = Array_updateR.symbol
+    lazy val Array_lengthR                = ctx.requiredMethodRef(ArrayTypeRef, nme.length)
+    def Array_length = Array_lengthR.symbol
+    lazy val Array_cloneR                 = ctx.requiredMethodRef(ArrayTypeRef, nme.clone_)
+    def Array_clone = Array_cloneR.symbol
+    lazy val ArrayConstructorR            = ctx.requiredMethodRef(ArrayTypeRef, nme.CONSTRUCTOR)
+    def ArrayConstructor = ArrayConstructorR.symbol
+
+  lazy val uncheckedStableClassRef: TypeRef = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedStable") // ### roll into annotations
+
+  lazy val UnitTypeRef = valueTypeRef("scala.Unit", BoxedUnitTypeRef, java.lang.Void.TYPE, UnitEnc)
+  def UnitClass = UnitTypeRef.symbol.asClass
+  lazy val BooleanTypeRef = valueTypeRef("scala.Boolean", BoxedBooleanTypeRef, java.lang.Boolean.TYPE, BooleanEnc)
+  def BooleanClass = BooleanTypeRef.symbol.asClass
+    lazy val Boolean_notR   = BooleanTypeRef.symbol.requiredMethodRef(nme.UNARY_!)
+    def Boolean_! = Boolean_notR.symbol
+    lazy val Boolean_andR = BooleanTypeRef.symbol.requiredMethodRef(nme.ZAND) // ### harmonize required... calls
+    def Boolean_&& = Boolean_andR.symbol
+    lazy val Boolean_orR  = BooleanTypeRef.symbol.requiredMethodRef(nme.ZOR)
+    def Boolean_|| = Boolean_orR.symbol
+
+  lazy val ByteTypeRef = valueTypeRef("scala.Byte", BoxedByteTypeRef, java.lang.Byte.TYPE, ByteEnc)
+  def ByteClass = ByteTypeRef.symbol.asClass
+  lazy val ShortTypeRef = valueTypeRef("scala.Short", BoxedShortTypeRef, java.lang.Short.TYPE, ShortEnc)
+  def ShortClass = ShortTypeRef.symbol.asClass
+  lazy val CharTypeRef = valueTypeRef("scala.Char", BoxedCharTypeRef, java.lang.Character.TYPE, CharEnc)
+  def CharClass = CharTypeRef.symbol.asClass
+  lazy val IntTypeRef = valueTypeRef("scala.Int", BoxedIntTypeRef, java.lang.Integer.TYPE, IntEnc)
+  def IntClass = IntTypeRef.symbol.asClass
+    lazy val Int_minusR   = IntTypeRef.symbol.requiredMethodRef(nme.MINUS, List(IntType))
+    def Int_- = Int_minusR.symbol
+    lazy val Int_plusR   = IntTypeRef.symbol.requiredMethodRef(nme.PLUS, List(IntType))
+    def Int_+ = Int_plusR.symbol
+    lazy val Int_divR   = IntTypeRef.symbol.requiredMethodRef(nme.DIV, List(IntType))
+    def Int_/ = Int_divR.symbol
+    lazy val Int_mulR   = IntTypeRef.symbol.requiredMethodRef(nme.MUL, List(IntType))
+    def Int_* = Int_mulR.symbol
+    lazy val Int_eqR   = IntTypeRef.symbol.requiredMethodRef(nme.EQ, List(IntType))
+    def Int_== = Int_eqR.symbol
+    lazy val Int_geR   = IntTypeRef.symbol.requiredMethodRef(nme.GE, List(IntType))
+    def Int_>= = Int_geR.symbol
+    lazy val Int_leR   = IntTypeRef.symbol.requiredMethodRef(nme.LE, List(IntType))
+    def Int_<= = Int_leR.symbol
+  lazy val LongTypeRef = valueTypeRef("scala.Long", BoxedLongTypeRef, java.lang.Long.TYPE, LongEnc)
+  def LongClass = LongTypeRef.symbol.asClass
+    lazy val Long_XOR_Long = LongTypeRef.member(nme.XOR).requiredSymbol(
       x => (x is Method) && (x.info.firstParamTypes.head isRef defn.LongClass)
     )
-    lazy val Long_LSR_Int = LongClass.info.member(nme.LSR).requiredSymbol(
+    lazy val Long_LSR_Int = LongTypeRef.member(nme.LSR).requiredSymbol(
       x => (x is Method) && (x.info.firstParamTypes.head isRef defn.IntClass)
     )
-  lazy val FloatClass = valueClassSymbol("scala.Float", BoxedFloatClass, java.lang.Float.TYPE, FloatEnc)
-  lazy val DoubleClass = valueClassSymbol("scala.Double", BoxedDoubleClass, java.lang.Double.TYPE, DoubleEnc)
-
-  lazy val BoxedUnitClass = ctx.requiredClass("scala.runtime.BoxedUnit")
-
-    lazy val BoxedUnit_UNIT = BoxedUnitClass.linkedClass.requiredValue("UNIT")
-
-  lazy val BoxedBooleanClass = ctx.requiredClass("java.lang.Boolean")
-  lazy val BoxedByteClass = ctx.requiredClass("java.lang.Byte")
-  lazy val BoxedShortClass = ctx.requiredClass("java.lang.Short")
-  lazy val BoxedCharClass = ctx.requiredClass("java.lang.Character")
-  lazy val BoxedIntClass = ctx.requiredClass("java.lang.Integer")
-  lazy val BoxedLongClass = ctx.requiredClass("java.lang.Long")
-  lazy val BoxedFloatClass = ctx.requiredClass("java.lang.Float")
-  lazy val BoxedDoubleClass = ctx.requiredClass("java.lang.Double")
+  lazy val FloatTypeRef = valueTypeRef("scala.Float", BoxedFloatTypeRef, java.lang.Float.TYPE, FloatEnc)
+  def FloatClass = FloatTypeRef.symbol.asClass
+  lazy val DoubleTypeRef = valueTypeRef("scala.Double", BoxedDoubleTypeRef, java.lang.Double.TYPE, DoubleEnc)
+  def DoubleClass = DoubleTypeRef.symbol.asClass
+
+  lazy val BoxedUnitTypeRef = ctx.requiredClassRef("scala.runtime.BoxedUnit")
+  def BoxedUnitClass = BoxedUnitTypeRef.symbol.asClass
+
+    lazy val BoxedUnit_UNIT = BoxedUnitTypeRef.symbol.linkedClass.requiredValue("UNIT") // ### replace with BoxedUnitModule?
+
+  lazy val BoxedBooleanTypeRef = ctx.requiredClassRef("java.lang.Boolean")
+  def BoxedBooleanClass = BoxedBooleanTypeRef.symbol.asClass
+  lazy val BoxedByteTypeRef = ctx.requiredClassRef("java.lang.Byte")
+  def BoxedByteClass = BoxedByteTypeRef.symbol.asClass
+  lazy val BoxedShortTypeRef = ctx.requiredClassRef("java.lang.Short")
+  def BoxedShortClass = BoxedShortTypeRef.symbol.asClass
+  lazy val BoxedCharTypeRef = ctx.requiredClassRef("java.lang.Character")
+  def BoxedCharClass = BoxedCharTypeRef.symbol.asClass
+  lazy val BoxedIntTypeRef = ctx.requiredClassRef("java.lang.Integer")
+  def BoxedIntClass = BoxedIntTypeRef.symbol.asClass
+  lazy val BoxedLongTypeRef = ctx.requiredClassRef("java.lang.Long")
+  def BoxedLongClass = BoxedLongTypeRef.symbol.asClass
+  lazy val BoxedFloatTypeRef = ctx.requiredClassRef("java.lang.Float")
+  def BoxedFloatClass = BoxedFloatTypeRef.symbol.asClass
+  lazy val BoxedDoubleTypeRef = ctx.requiredClassRef("java.lang.Double")
+  def BoxedDoubleClass = BoxedDoubleTypeRef.symbol.asClass
 
   lazy val BoxedBooleanModule = ctx.requiredModule("java.lang.Boolean")
   lazy val BoxedByteModule    = ctx.requiredModule("java.lang.Byte")
@@ -289,8 +342,8 @@ class Definitions {
   lazy val RepeatedParamClass     = specialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, ObjectType, SeqType)
 
   // fundamental classes
-  lazy val StringClass                  = ctx.requiredClass("java.lang.String")
-  lazy val StringModule                 = StringClass.linkedClass
+  lazy val StringClass                = ctx.requiredClass("java.lang.String")
+  lazy val StringModule               = StringClass.linkedClass
 
     lazy val String_+ = newMethod(StringClass, nme.raw.PLUS, methOfAny(StringType), Final)
     lazy val String_valueOf_Object = StringModule.info.member(nme.valueOf).suchThat(_.info.firstParamTypes match {
@@ -298,71 +351,117 @@ class Definitions {
       case _ => false
     }).symbol
 
-  // in scalac modified to have Any as parrent
-
-  lazy val SerializableClass         = ctx.requiredClass("scala.Serializable")
   lazy val JavaCloneableClass        = ctx.requiredClass("java.lang.Cloneable")
-  lazy val StringBuilderClass        = ctx.requiredClass("scala.collection.mutable.StringBuilder")
-  lazy val NullPointerExceptionClass = ctx.requiredClass(jnme.NPException)
-  lazy val MatchErrorClass           = ctx.requiredClass("scala.MatchError")
-  lazy val MatchErrorType            = MatchErrorClass.typeRef
-
-  lazy val StringAddClass               = ctx.requiredClass("scala.runtime.StringAdd")
-
-    lazy val StringAdd_+ = StringAddClass.requiredMethod(nme.raw.PLUS)
-
-  lazy val PairClass                    = ctx.requiredClass("dotty.Pair")
-  lazy val PartialFunctionClass         = ctx.requiredClass("scala.PartialFunction")
-  lazy val AbstractPartialFunctionClass = ctx.requiredClass("scala.runtime.AbstractPartialFunction")
-  lazy val SymbolClass                  = ctx.requiredClass("scala.Symbol")
-  lazy val ClassClass                   = ctx.requiredClass("java.lang.Class")
-  lazy val DynamicClass                 = ctx.requiredClass("scala.Dynamic")
-  lazy val OptionClass                  = ctx.requiredClass("scala.Option")
-  lazy val BoxedNumberClass             = ctx.requiredClass("java.lang.Number")
-  lazy val ThrowableClass               = ctx.requiredClass("java.lang.Throwable")
-  lazy val ClassCastExceptionClass      = ctx.requiredClass("java.lang.ClassCastException")
-  lazy val JavaSerializableClass        = ctx.requiredClass("java.lang.Serializable")
-  lazy val ComparableClass              = ctx.requiredClass("java.lang.Comparable")
-  lazy val ProductClass                 = ctx.requiredClass("scala.Product")
-    lazy val Product_canEqual = ProductClass.requiredMethod(nme.canEqual_)
-    lazy val Product_productArity = ProductClass.requiredMethod(nme.productArity)
-    lazy val Product_productPrefix = ProductClass.requiredMethod(nme.productPrefix)
-  lazy val LanguageModuleClass          = ctx.requiredModule("dotty.language").moduleClass.asClass
-  lazy val NonLocalReturnControlClass   = ctx.requiredClass("scala.runtime.NonLocalReturnControl")
+  lazy val NullPointerExceptionClass = ctx.requiredClass("java.lang.NullPointerException")
+  lazy val ClassClass                = ctx.requiredClass("java.lang.Class")
+  lazy val BoxedNumberClass          = ctx.requiredClass("java.lang.Number")
+  lazy val ThrowableClass            = ctx.requiredClass("java.lang.Throwable")
+  lazy val ClassCastExceptionClass   = ctx.requiredClass("java.lang.ClassCastException")
+  lazy val JavaSerializableClass     = ctx.requiredClass("java.lang.Serializable")
+  lazy val ComparableClass           = ctx.requiredClass("java.lang.Comparable")
+
+  // in scalac modified to have Any as parent
+
+  lazy val SerializableTypeRef       = ctx.requiredClassRef("scala.Serializable")
+  def SerializableClass = SerializableTypeRef.symbol.asClass
+  lazy val StringBuilderTypeRef      = ctx.requiredClassRef("scala.collection.mutable.StringBuilder")
+  def StringBuilderClass = StringBuilderTypeRef.symbol.asClass
+  lazy val MatchErrorTypeRef         = ctx.requiredClassRef("scala.MatchError")
+  def MatchErrorClass = MatchErrorTypeRef.symbol.asClass
+
+  lazy val StringAddTypeRef          = ctx.requiredClassRef("scala.runtime.StringAdd")
+  def StringAddClass = StringAddTypeRef.symbol.asClass
+
+    lazy val StringAdd_plusR = StringAddTypeRef.symbol.requiredMethodRef(nme.raw.PLUS)
+    def StringAdd_+ = StringAdd_plusR.symbol
+
+  lazy val PairTypeRef                    = ctx.requiredClassRef("dotty.Pair")
+  def PairClass = PairTypeRef.symbol.asClass
+  lazy val PartialFunctionTypeRef         = ctx.requiredClassRef("scala.PartialFunction")
+  def PartialFunctionClass = PartialFunctionTypeRef.symbol.asClass
+  lazy val AbstractPartialFunctionTypeRef = ctx.requiredClassRef("scala.runtime.AbstractPartialFunction")
+  def AbstractPartialFunctionClass = AbstractPartialFunctionTypeRef.symbol.asClass
+  lazy val SymbolTypeRef                  = ctx.requiredClassRef("scala.Symbol")
+  def SymbolClass = SymbolTypeRef.symbol.asClass
+  lazy val DynamicTypeRef                 = ctx.requiredClassRef("scala.Dynamic")
+  def DynamicClass = DynamicTypeRef.symbol.asClass
+  lazy val OptionTypeRef                  = ctx.requiredClassRef("scala.Option")
+  def OptionClass = OptionTypeRef.symbol.asClass
+  lazy val ProductTypeRef                 = ctx.requiredClassRef("scala.Product")
+  def ProductClass = ProductTypeRef.symbol.asClass
+    lazy val Product_canEqualR = ProductTypeRef.symbol.requiredMethodRef(nme.canEqual_)
+    def Product_canEqual = Product_canEqualR.symbol
+    lazy val Product_productArityR = ProductTypeRef.symbol.requiredMethod(nme.productArity)
+    def Product_productArity = Product_productArityR.symbol
+    lazy val Product_productPrefixR = ProductTypeRef.symbol.requiredMethod(nme.productPrefix)
+    def Product_productPrefix = Product_productPrefixR.symbol
+  lazy val LanguageModuleTypeRef          = ctx.requiredModule("dotty.language").moduleClass.asClass
+  def LanguageModuleClass = LanguageModuleTypeRef.symbol.asClass // ### Needed? Maube just keep LanguageModule?
+  lazy val NonLocalReturnControlTypeRef   = ctx.requiredClassRef("scala.runtime.NonLocalReturnControl")
 
   // Annotation base classes
-  lazy val AnnotationClass              = ctx.requiredClass("scala.annotation.Annotation")
-  lazy val ClassfileAnnotationClass     = ctx.requiredClass("scala.annotation.ClassfileAnnotation")
-  lazy val StaticAnnotationClass        = ctx.requiredClass("scala.annotation.StaticAnnotation")
-  lazy val TailrecAnnotationClass       = ctx.requiredClass("scala.annotation.tailrec")
-  lazy val RemoteAnnot                   = ctx.requiredClass("scala.remote")
-  lazy val SerialVersionUIDAnnot         = ctx.requiredClass("scala.SerialVersionUID")
-  lazy val TransientAnnot                = ctx.requiredClass("scala.transient")
-  lazy val NativeAnnot                   = ctx.requiredClass("scala.native")
-  lazy val ScalaStrictFPAnnot            = ctx.requiredClass("scala.annotation.strictfp")
+  lazy val AnnotationTypeRef              = ctx.requiredClassRef("scala.annotation.Annotation") // ### AnnotationTypeRef --> AnnotRef?
+  def AnnotationClass = AnnotationTypeRef.symbol.asClass
+  lazy val ClassfileAnnotationTypeRef     = ctx.requiredClassRef("scala.annotation.ClassfileAnnotation")
+  def ClassfileAnnotationClass = ClassfileAnnotationTypeRef.symbol.asClass
+  lazy val StaticAnnotationTypeRef        = ctx.requiredClassRef("scala.annotation.StaticAnnotation")
+  def StaticAnnotationClass = StaticAnnotationTypeRef.symbol.asClass
+  lazy val TailrecAnnotationTypeRef       = ctx.requiredClassRef("scala.annotation.tailrec")
+  def TailrecAnnotationClass = TailrecAnnotationTypeRef.symbol.asClass
+  lazy val RemoteAnnotRef                   = ctx.requiredClassRef("scala.remote")
+  def RemoteAnnot = RemoteAnnotRef.symbol.asClass
+  lazy val SerialVersionUIDAnnotRef         = ctx.requiredClassRef("scala.SerialVersionUID")
+  def SerialVersionUIDAnnot = SerialVersionUIDAnnotRef.symbol.asClass
+  lazy val TransientAnnotRef                = ctx.requiredClassRef("scala.transient")
+  def TransientAnnot = TransientAnnotRef.symbol.asClass
+  lazy val NativeAnnotRef                   = ctx.requiredClassRef("scala.native")
+  def NativeAnnot = NativeAnnotRef.symbol.asClass
+  lazy val ScalaStrictFPAnnotRef            = ctx.requiredClassRef("scala.annotation.strictfp")
+  def ScalaStrictFPAnnot = ScalaStrictFPAnnotRef.symbol.asClass
 
   // Annotation classes
-  lazy val AliasAnnot = ctx.requiredClass("dotty.annotation.internal.Alias")
-  lazy val ChildAnnot = ctx.requiredClass("dotty.annotation.internal.Child")
-  lazy val RepeatedAnnot = ctx.requiredClass("dotty.annotation.internal.Repeated")
-  lazy val InvariantBetweenClass = ctx.requiredClass("dotty.annotation.internal.InvariantBetween")
-  lazy val CovariantBetweenClass = ctx.requiredClass("dotty.annotation.internal.CovariantBetween")
-  lazy val ContravariantBetweenClass = ctx.requiredClass("dotty.annotation.internal.ContravariantBetween")
-  lazy val ScalaSignatureAnnot = ctx.requiredClass("scala.reflect.ScalaSignature")
-  lazy val ScalaLongSignatureAnnot = ctx.requiredClass("scala.reflect.ScalaLongSignature")
-  lazy val TASTYSignatureAnnot = ctx.requiredClass("scala.annotation.internal.TASTYSignature")
-  lazy val TASTYLongSignatureAnnot = ctx.requiredClass("scala.annotation.internal.TASTYLongSignature")
-  lazy val DeprecatedAnnot = ctx.requiredClass("scala.deprecated")
-  lazy val MigrationAnnot = ctx.requiredClass("scala.annotation.migration")
-  lazy val AnnotationDefaultAnnot = ctx.requiredClass("dotty.annotation.internal.AnnotationDefault")
-  lazy val ThrowsAnnot = ctx.requiredClass("scala.throws")
-  lazy val UncheckedAnnot = ctx.requiredClass("scala.unchecked")
-  lazy val UncheckedStableAnnot = ctx.requiredClass("scala.annotation.unchecked.uncheckedStable")
-  lazy val UncheckedVarianceAnnot = ctx.requiredClass("scala.annotation.unchecked.uncheckedVariance")
-  lazy val VolatileAnnot = ctx.requiredClass("scala.volatile")
-  lazy val FieldMetaAnnot = ctx.requiredClass("scala.annotation.meta.field")
-  lazy val GetterMetaAnnot = ctx.requiredClass("scala.annotation.meta.getter")
-  lazy val SetterMetaAnnot = ctx.requiredClass("scala.annotation.meta.setter")
+  lazy val AliasAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.Alias")
+  def AliasAnnot = AliasAnnotRef.symbol.asClass
+  lazy val ChildAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.Child")
+  def ChildAnnot = ChildAnnotRef.symbol.asClass
+  lazy val RepeatedAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.Repeated")
+  def RepeatedAnnot = RepeatedAnnotRef.symbol.asClass
+  lazy val InvariantBetweenAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.InvariantBetween")
+  def InvariantBetweenAnnot = InvariantBetweenAnnotRef.symbol.asClass
+  lazy val CovariantBetweenAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.CovariantBetween")
+  def CovariantBetweenAnnot = CovariantBetweenAnnotRef.symbol.asClass
+  lazy val ContravariantBetweenAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.ContravariantBetween")
+  def ContravariantBetweenAnnot = ContravariantBetweenAnnotRef.symbol.asClass
+  lazy val ScalaSignatureAnnotRef = ctx.requiredClassRef("scala.reflect.ScalaSignature")
+  def ScalaSignatureAnnot = ScalaSignatureAnnotRef.symbol.asClass
+  lazy val ScalaLongSignatureAnnotRef = ctx.requiredClassRef("scala.reflect.ScalaLongSignature")
+  def ScalaLongSignatureAnnot = ScalaLongSignatureAnnotRef.symbol.asClass
+  lazy val TASTYSignatureAnnotRef = ctx.requiredClassRef("scala.annotation.internal.TASTYSignature")
+  def TASTYSignatureAnnot = TASTYSignatureAnnotRef.symbol.asClass
+  lazy val TASTYLongSignatureAnnotRef = ctx.requiredClassRef("scala.annotation.internal.TASTYLongSignature")
+  def TASTYLongSignatureAnnot = TASTYLongSignatureAnnotRef.symbol.asClass
+  lazy val DeprecatedAnnotRef = ctx.requiredClassRef("scala.deprecated")
+  def DeprecatedAnnot = DeprecatedAnnotRef.symbol.asClass
+  lazy val MigrationAnnotRef = ctx.requiredClassRef("scala.annotation.migration")
+  def MigrationAnnot = MigrationAnnotRef.symbol.asClass
+  lazy val AnnotationDefaultAnnotRef = ctx.requiredClassRef("dotty.annotation.internal.AnnotationDefault")
+  def AnnotationDefaultAnnot = AnnotationDefaultAnnotRef.symbol.asClass
+  lazy val ThrowsAnnotRef = ctx.requiredClassRef("scala.throws")
+  def ThrowsAnnot = ThrowsAnnotRef.symbol.asClass
+  lazy val UncheckedAnnotRef = ctx.requiredClassRef("scala.unchecked")
+  def UncheckedAnnot = UncheckedAnnotRef.symbol.asClass
+  lazy val UncheckedStableAnnotRef = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedStable")
+  def UncheckedStableAnnot = UncheckedStableAnnotRef.symbol.asClass
+  lazy val UncheckedVarianceAnnotRef = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedVariance")
+  def UncheckedVarianceAnnot = UncheckedVarianceAnnotRef.symbol.asClass
+  lazy val VolatileAnnotRef = ctx.requiredClassRef("scala.volatile")
+  def VolatileAnnot = VolatileAnnotRef.symbol.asClass
+  lazy val FieldMetaAnnotRef = ctx.requiredClassRef("scala.annotation.meta.field")
+  def FieldMetaAnnot = FieldMetaAnnotRef.symbol.asClass
+  lazy val GetterMetaAnnotRef = ctx.requiredClassRef("scala.annotation.meta.getter")
+  def GetterMetaAnnot = GetterMetaAnnotRef.symbol.asClass
+  lazy val SetterMetaAnnotRef = ctx.requiredClassRef("scala.annotation.meta.setter")
+  def SetterMetaAnnot = SetterMetaAnnotRef.symbol.asClass
 
   // convenient one-parameter method types
   def methOfAny(tp: Type) = MethodType(List(AnyType), tp)
@@ -376,23 +475,23 @@ class Definitions {
   def AnyRefType: Type = AnyRefAlias.typeRef
   def NothingType: Type = NothingClass.typeRef
   def NullType: Type = NullClass.typeRef
-  def SeqType: Type = SeqClass.typeRef
-
-  def UnitType: Type = UnitClass.typeRef
-  def BooleanType: Type = BooleanClass.typeRef
-  def ByteType: Type = ByteClass.typeRef
-  def ShortType: Type = ShortClass.typeRef
-  def CharType: Type = CharClass.typeRef
-  def IntType: Type = IntClass.typeRef
-  def LongType: Type = LongClass.typeRef
-  def FloatType: Type = FloatClass.typeRef
-  def DoubleType: Type = DoubleClass.typeRef
-  def PairType: Type = PairClass.typeRef
+  def SeqType: Type = SeqTypeRef
+
+  def UnitType: Type = UnitTypeRef
+  def BooleanType: Type = BooleanTypeRef
+  def ByteType: Type = ByteTypeRef
+  def ShortType: Type = ShortTypeRef
+  def CharType: Type = CharTypeRef
+  def IntType: Type = IntTypeRef
+  def LongType: Type = LongTypeRef
+  def FloatType: Type = FloatTypeRef
+  def DoubleType: Type = DoubleTypeRef
+  def PairType: Type = PairTypeRef
   def StringType: Type = StringClass.typeRef
   def RepeatedParamType = RepeatedParamClass.typeRef
   def ThrowableType = ThrowableClass.typeRef
-  def OptionType = OptionClass.typeRef
-  def VolatileAnnotType = VolatileAnnot.typeRef
+  def OptionType = OptionTypeRef
+  def VolatileAnnotType = VolatileAnnotRef
 
   def ClassType(arg: Type)(implicit ctx: Context) = {
     val ctype = ClassClass.typeRef
@@ -409,15 +508,15 @@ class Definitions {
 
   object FunctionType {
     def apply(args: List[Type], resultType: Type)(implicit ctx: Context) =
-      FunctionClass(args.length).typeRef.appliedTo(args ::: resultType :: Nil)
+      FunctionTypeRef(args.length).appliedTo(args ::: resultType :: Nil)
     def unapply(ft: Type)(implicit ctx: Context)/*: Option[(List[Type], Type)]*/ = {
       // -language:keepUnions difference: unapply needs result type because inferred type
       // is Some[(List[Type], Type)] | None, which is not a legal unapply type.
       val tsym = ft.typeSymbol
       lazy val targs = ft.argInfos
-      if ((FunctionClasses contains tsym) &&
-          (targs.length - 1 <= MaxFunctionArity) &&
-          (FunctionClass(targs.length - 1) == tsym)) Some(targs.init, targs.last)
+      val numArgs = targs.length - 1
+      if (numArgs >= 0 && numArgs <= MaxFunctionArity &&
+          (FunctionTypeRef(numArgs).symbol == tsym)) Some(targs.init, targs.last)
       else None
     }
   }
@@ -425,9 +524,9 @@ class Definitions {
   object ArrayType {
     def apply(elem: Type)(implicit ctx: Context) =
       if (ctx.erasedTypes) JavaArrayType(elem)
-      else ArrayClass.typeRef.appliedTo(elem :: Nil)
+      else ArrayTypeRef.appliedTo(elem :: Nil)
     def unapply(tp: Type)(implicit ctx: Context): Option[Type] = tp.dealias match {
-      case at: RefinedType if (at isRef ArrayClass) && at.argInfos.length == 1 => Some(at.argInfos.head)
+      case at: RefinedType if (at isRef ArrayTypeRef.symbol) && at.argInfos.length == 1 => Some(at.argInfos.head)
       case _ => None
     }
   }
@@ -448,43 +547,67 @@ class Definitions {
 
   // ----- Symbol sets ---------------------------------------------------
 
-  lazy val AbstractFunctionClass = mkArityArray("scala.runtime.AbstractFunction", MaxFunctionArity, 0)
-  lazy val FunctionClass = mkArityArray("scala.Function", MaxFunctionArity, 0)
-    lazy val Function0_apply = FunctionClass(0).requiredMethod(nme.apply)
+  lazy val AbstractFunctionTypeRef = mkArityArray("scala.runtime.AbstractFunction", MaxFunctionArity, 0)
+  def AbstractFunctionClass = AbstractFunctionTypeRef.map(_.symbol.asClass)
+  lazy val FunctionTypeRef = mkArityArray("scala.Function", MaxFunctionArity, 0)
+  def FunctionClass = FunctionTypeRef.map(_.symbol.asClass)
+    lazy val Function0_applyR = FunctionTypeRef(0).symbol.requiredMethodRef(nme.apply)
+    def Function0_apply = Function0_applyR.symbol
 
-  lazy val TupleClass = mkArityArray("scala.Tuple", MaxTupleArity, 2)
-  lazy val ProductNClass = mkArityArray("scala.Product", MaxTupleArity, 0)
+  lazy val TupleTypeRef = mkArityArray("scala.Tuple", MaxTupleArity, 2)
+  lazy val ProductNTypeRef = mkArityArray("scala.Product", MaxTupleArity, 0)
 
-  lazy val FunctionClasses: Set[Symbol] = FunctionClass.toSet
-  lazy val TupleClasses: Set[Symbol] = TupleClass.toSet
-  lazy val ProductClasses: Set[Symbol] = ProductNClass.toSet
+  lazy val FunctionTypeRefs: Set[TypeRef] = FunctionTypeRef.toSet
+  lazy val TupleTypeRefs: Set[TypeRef] = TupleTypeRef.toSet
+  lazy val ProductTypeRefs: Set[TypeRef] = ProductNTypeRef.toSet
 
-  /** `Modules whose members are in the default namespace and their module classes */
-  lazy val UnqualifiedOwners = RootImports.toSet ++ RootImports.map(_.moduleClass)
+  /** If type refers to a class in the scala package, its name, otherwise EmptyTypeName */
+  def scalaClassName(ref: Type)(implicit ctx: Context): TypeName = {
+    val cls = ref.classSymbol
+    if (cls.isClass && cls.owner == ScalaPackageClass) cls.asClass.name else EmptyTypeName
+  }
 
-  lazy val PhantomClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass)
+  def isVarArityClass(cls: Symbol, prefix: Name) = // ### use scalaClassName
+    cls.owner == ScalaPackageClass && cls.name.startsWith(prefix) &&
+    cls.name.drop(prefix.length).forall(_.isDigit)
+
+  def isFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.Function)
+  def isAbstractFunctionClass(cls: Symbol) = isVarArityClass(cls, tpnme.AbstractFunction)
+  def isTupleClass(cls: Symbol) = isVarArityClass(cls, tpnme.Tuple)
+  def isProductClass(cls: Symbol) = isVarArityClass(cls, tpnme.Product)
+
+  val RootImportFns = List[() => TermRef](
+      () => JavaLangPackageVal.termRef,
+      () => ScalaPackageVal.termRef,
+      () => ScalaPredefModuleRef,
+      () => DottyPredefModuleRef)
 
-  lazy val isPolymorphicAfterErasure = Set[Symbol](Any_isInstanceOf, Any_asInstanceOf, newRefArrayMethod)
+  lazy val RootImportTypes = RootImportFns.map(_())
 
-  val RootImportFns = List[() => Symbol](() => JavaLangPackageVal, () => ScalaPackageVal, () => ScalaPredefModule, () => DottyPredefModule)
+  /** `Modules whose members are in the default namespace and their module classes */
+  lazy val UnqualifiedOwnerTypes: Set[NamedType] =
+    RootImportTypes.toSet[NamedType] ++ RootImportTypes.map(_.symbol.moduleClass.typeRef)
+
+  lazy val PhantomClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass)
 
-  lazy val RootImports = RootImportFns.map(_())
+  lazy val isPolymorphicAfterErasure = // ### Can't be a lazy val, because of newRefArrayMethod!
+    Set[Symbol](Any_isInstanceOf, Any_asInstanceOf, newRefArrayMethod)
 
   def isTupleType(tp: Type)(implicit ctx: Context) = {
     val arity = tp.dealias.argInfos.length
-    arity <= MaxTupleArity && (tp isRef TupleClass(arity))
+    arity <= MaxTupleArity && TupleTypeRef(arity) != null && (tp isRef TupleTypeRef(arity).symbol)
   }
 
   def tupleType(elems: List[Type]) = {
-    TupleClass(elems.size).typeRef.appliedTo(elems)
+    TupleTypeRef(elems.size).appliedTo(elems)
   }
 
   def isProductSubType(tp: Type)(implicit ctx: Context) =
-    (tp derivesFrom ProductClass) && tp.baseClasses.exists(ProductClasses contains _)
+    (tp derivesFrom ProductTypeRef.symbol) && tp.baseClasses.exists(isProductClass)
 
   def isFunctionType(tp: Type)(implicit ctx: Context) = {
     val arity = functionArity(tp)
-    0 <= arity && arity <= MaxFunctionArity && (tp isRef FunctionClass(arity))
+    0 <= arity && arity <= MaxFunctionArity && (tp isRef FunctionTypeRef(arity).symbol)
   }
 
   def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
@@ -556,54 +679,57 @@ class Definitions {
 
   // ----- primitive value class machinery ------------------------------------------
 
-  lazy val ScalaNumericValueClassList = List(
-    ByteClass,
-    ShortClass,
-    CharClass,
-    IntClass,
-    LongClass,
-    FloatClass,
-    DoubleClass)
-
-  lazy val ScalaNumericValueClasses: collection.Set[Symbol] = ScalaNumericValueClassList.toSet
-  lazy val ScalaValueClasses: collection.Set[Symbol] = ScalaNumericValueClasses + UnitClass + BooleanClass
-
-  lazy val ScalaBoxedClasses = ScalaValueClasses map boxedClass
-
-  private[this] val _boxedClass = mutable.Map[Symbol, Symbol]()
-  private[this] val _unboxedClass = mutable.Map[Symbol, Symbol]()
-
-  private[this] val _javaTypeToValueClass = mutable.Map[Class[_], Symbol]()
-  private[this] val _valueClassToJavaType = mutable.Map[Symbol, Class[_]]()
-  private[this] val _valueClassEnc = mutable.Map[Symbol, Int]()
-
-  val boxedClass: collection.Map[Symbol, Symbol] = _boxedClass
-  val unboxedClass: collection.Map[Symbol, Symbol] = _boxedClass
-  val javaTypeToValueClass: collection.Map[Class[_], Symbol] = _javaTypeToValueClass
-  val valueClassToJavaType: collection.Map[Symbol, Class[_]] = _valueClassToJavaType
-  val valueClassEnc: collection.Map[Symbol, Int] = _valueClassEnc
-
-  private def valueClassSymbol(name: String, boxed: ClassSymbol, jtype: Class[_], enc: Int): ClassSymbol = {
-    val vcls = ctx.requiredClass(name)
-    _unboxedClass(boxed) = vcls
-    _boxedClass(vcls) = boxed
-    _javaTypeToValueClass(jtype) = vcls
-    _valueClassToJavaType(vcls) = jtype
-    _valueClassEnc(vcls) = enc
+  lazy val ScalaNumericValueTypeList = List(
+    ByteTypeRef,
+    ShortTypeRef,
+    CharTypeRef,
+    IntTypeRef,
+    LongTypeRef,
+    FloatTypeRef,
+    DoubleTypeRef)
+
+  lazy val ScalaNumericValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypeList.toSet
+  def ScalaNumericValueClasses = ScalaNumericValueTypes.map(_.symbol)
+  lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes + UnitTypeRef + BooleanTypeRef
+  def ScalaValueClasses = ScalaValueTypes.map(_.symbol)
+
+  lazy val ScalaBoxedTypeRefs = ScalaValueTypes map boxedTypeRef
+  def ScalaBoxedClasses = ScalaBoxedTypeRefs.map(_.symbol)
+
+  private[this] val _boxedTypeRef = mutable.Map[TypeRef, TypeRef]() // ### Maps over typerefs are not robust!
+  private[this] val _unboxedTypeRef = mutable.Map[TypeRef, TypeRef]()
+
+  private[this] val _javaTypeToValueTypeRef = mutable.Map[Class[_], TypeRef]()
+  private[this] val _valueTypeRefToJavaType = mutable.Map[TypeRef, Class[_]]()
+  private[this] val _valueTypeEnc = mutable.Map[TypeRef, Int]()
+
+  val boxedTypeRef: collection.Map[TypeRef, TypeRef] = _boxedTypeRef
+  val unboxedTypeRef: collection.Map[TypeRef, TypeRef] = _boxedTypeRef
+  val javaTypeToValueTypeRef: collection.Map[Class[_], TypeRef] = _javaTypeToValueTypeRef
+  val valueTypeRefToJavaType: collection.Map[TypeRef, Class[_]] = _valueTypeRefToJavaType
+  val valueTypeEnc: collection.Map[TypeRef, Int] = _valueTypeEnc
+
+  private def valueTypeRef(name: String, boxed: TypeRef, jtype: Class[_], enc: Int): TypeRef = {
+    val vcls = ctx.requiredClassRef(name)
+    _unboxedTypeRef(boxed) = vcls
+    _boxedTypeRef(vcls) = boxed
+    _javaTypeToValueTypeRef(jtype) = vcls
+    _valueTypeRefToJavaType(vcls) = jtype
+    _valueTypeEnc(vcls) = enc
     vcls
   }
 
   /** The classes for which a Ref type exists. */
-  lazy val refClassKeys: collection.Set[Symbol] = ScalaNumericValueClasses + BooleanClass + ObjectClass
+  lazy val refTypeKeys: collection.Set[TypeRef] = ScalaNumericValueTypes + BooleanTypeRef + ObjectClass.typeRef
 
-  lazy val refClass: Map[Symbol, Symbol] =
-    refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.${rc.name}Ref")).toMap
+  lazy val refTypeRef: Map[TypeRef, TypeRef] =
+    refTypeKeys.map(rc => rc -> ctx.requiredClassRef(s"scala.runtime.${rc.name}Ref")).toMap
 
-  lazy val volatileRefClass: Map[Symbol, Symbol] =
-    refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.Volatile${rc.name}Ref")).toMap
+  lazy val volatileRefTypeRef: Map[TypeRef, TypeRef] =
+    refTypeKeys.map(rc => rc -> ctx.requiredClassRef(s"scala.runtime.Volatile${rc.name}Ref")).toMap
 
-  lazy val boxedRefClasses: collection.Set[Symbol] =
-    refClassKeys.flatMap(k => Set(refClass(k), volatileRefClass(k)))
+  lazy val boxedRefTypeRefs: collection.Set[TypeRef] =
+    refTypeKeys.flatMap(k => Set(refTypeRef(k), volatileRefTypeRef(k)))
 
   def wrapArrayMethodName(elemtp: Type): TermName = {
     val cls = elemtp.classSymbol
@@ -622,8 +748,10 @@ class Definitions {
   val BooleanEnc = 17
   val UnitEnc = 19
 
-  def isValueSubClass(cls1: Symbol, cls2: Symbol)(implicit ctx: Context) =
-    valueClassEnc(cls2) % valueClassEnc(cls1) == 0
+  def isValueSubType(tref1: TypeRef, tref2: TypeRef)(implicit ctx: Context) = // ### Not stable!
+    valueTypeEnc(tref2) % valueTypeEnc(tref1) == 0
+  def isValueSubClass(sym1: Symbol, sym2: Symbol) =
+    isValueSubType(sym1.typeRef, sym2.typeRef)
 
   // ----- Initialization ---------------------------------------------------