Merge pull request #928 from dotty-staging/stdlib-definitions

Make Definitions survive recompilation of core definitions.

17 files changed, 94 insertions, 101 deletions

diff --git a/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala b/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
index 779f0d647..9c01aaa9a 100644
--- a/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
+++ b/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
@@ -53,7 +53,7 @@ class AugmentScala2Traits extends MiniPhaseTransform with IdentityDenotTransform
         owner = mixin.owner,
         name = mixin.name.implClassName,
         flags = Abstract | Scala2x,
-        parents = defn.ObjectClass.typeRef :: Nil,
+        parents = defn.ObjectType :: Nil,
         assocFile = mixin.assocFile).enteredAfter(thisTransform)
 
       def implMethod(meth: TermSymbol): Symbol = {
diff --git a/src/dotty/tools/dotc/transform/CapturedVars.scala b/src/dotty/tools/dotc/transform/CapturedVars.scala
index 0f1a60282..cd05589c3 100644
--- a/src/dotty/tools/dotc/transform/CapturedVars.scala
+++ b/src/dotty/tools/dotc/transform/CapturedVars.scala
@@ -24,9 +24,30 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo
   val phaseName: String = "capturedVars"
   val treeTransform = new Transform(Set())
 
+  private class RefInfo(implicit ctx: Context) {
+    /** The classes for which a Ref type exists. */
+    val refClassKeys: collection.Set[Symbol] =
+      defn.ScalaNumericValueClasses() + defn.BooleanClass + defn.ObjectClass
+
+    val refClass: Map[Symbol, Symbol] =
+      refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.${rc.name}Ref")).toMap
+
+    val volatileRefClass: Map[Symbol, Symbol] =
+      refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.Volatile${rc.name}Ref")).toMap
+
+    val boxedRefClasses: collection.Set[Symbol] =
+      refClassKeys.flatMap(k => Set(refClass(k), volatileRefClass(k)))
+  }
+
   class Transform(captured: collection.Set[Symbol]) extends TreeTransform {
     def phase = thisTransform
 
+    private var myRefInfo: RefInfo = null
+    private def refInfo(implicit ctx: Context) = {
+      if (myRefInfo == null) myRefInfo = new RefInfo()
+      myRefInfo
+    }
+
     private class CollectCaptured(implicit ctx: Context) extends EnclosingMethodTraverser {
       private val captured = mutable.HashSet[Symbol]()
       def traverse(enclMeth: Symbol, tree: Tree)(implicit ctx: Context) = tree match {
@@ -54,16 +75,19 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo
     /** The {Volatile|}{Int|Double|...|Object}Ref class corresponding to the class `cls`,
      *  depending on whether the reference should be @volatile
      */
-    def refCls(cls: Symbol, isVolatile: Boolean)(implicit ctx: Context): Symbol = {
-      val refMap = if (isVolatile) defn.volatileRefClass else defn.refClass
-      refMap.getOrElse(cls, refMap(defn.ObjectClass))
+    def refClass(cls: Symbol, isVolatile: Boolean)(implicit ctx: Context): Symbol = {
+      val refMap = if (isVolatile) refInfo.volatileRefClass else refInfo.refClass
+      if (cls.isClass)  {
+        refMap.getOrElse(cls, refMap(defn.ObjectClass))
+      }
+      else refMap(defn.ObjectClass)
     }
 
     override def prepareForValDef(vdef: ValDef)(implicit ctx: Context) = {
       val sym = vdef.symbol
       if (captured contains sym) {
         val newd = sym.denot(ctx.withPhase(thisTransform)).copySymDenotation(
-          info = refCls(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)).typeRef,
+          info = refClass(sym.info.classSymbol, sym.hasAnnotation(defn.VolatileAnnot)).typeRef,
           initFlags = sym.flags &~ Mutable)
         newd.removeAnnotation(defn.VolatileAnnot)
         newd.installAfter(thisTransform)
@@ -113,7 +137,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisTransfo
         case TypeApply(Select(qual, nme.asInstanceOf_), _) =>
           val Select(_, nme.elem) = qual
           recur(qual)
-        case Select(_, nme.elem) if defn.boxedRefClasses.contains(lhs.symbol.maybeOwner) =>
+        case Select(_, nme.elem) if refInfo.boxedRefClasses.contains(lhs.symbol.maybeOwner) =>
           val tempDef = transformFollowing(SyntheticValDef(ctx.freshName("ev$").toTermName, tree.rhs))
           transformFollowing(Block(tempDef :: Nil, cpy.Assign(tree)(lhs, ref(tempDef.symbol))))
         case _ =>
diff --git a/src/dotty/tools/dotc/transform/ClassOf.scala b/src/dotty/tools/dotc/transform/ClassOf.scala
index 4d6bf2dc9..51a68f903 100644
--- a/src/dotty/tools/dotc/transform/ClassOf.scala
+++ b/src/dotty/tools/dotc/transform/ClassOf.scala
@@ -5,7 +5,7 @@ import ast.tpd
 import core.Constants.Constant
 import core.Contexts.Context
 import core.StdNames.nme
-import core.Symbols.TermSymbol
+import core.Symbols.{defn,TermSymbol}
 import core.TypeErasure
 import TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
 
@@ -24,30 +24,14 @@ class ClassOf extends MiniPhaseTransform {
   private var classOfMethod: TermSymbol = _
 
   override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): TreeTransform = {
-    val predefModule = ctx.definitions.ScalaPredefModule
-    classOfMethod = ctx.requiredMethod(predefModule.moduleClass.asClass, nme.classOf)
+    classOfMethod = defn.ScalaPredefModule.requiredMethod(nme.classOf)
     this
   }
 
-  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree = {
+  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree =
     if (tree.symbol eq classOfMethod) {
-      val tp = tree.args.head.tpe
-      val defn = ctx.definitions
-      val claz = tp.classSymbol
-
-      def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_).ensureConforms(tree.tpe)
-      claz match {
-        case defn.BooleanClass => TYPE(defn.BoxedBooleanModule)
-        case defn.ByteClass    => TYPE(defn.BoxedByteModule)
-        case defn.ShortClass   => TYPE(defn.BoxedShortModule)
-        case defn.CharClass    => TYPE(defn.BoxedCharModule)
-        case defn.IntClass     => TYPE(defn.BoxedIntModule)
-        case defn.LongClass    => TYPE(defn.BoxedLongModule)
-        case defn.FloatClass   => TYPE(defn.BoxedFloatModule)
-        case defn.DoubleClass  => TYPE(defn.BoxedDoubleModule)
-        case defn.UnitClass    => TYPE(defn.BoxedVoidModule)
-        case _                 => Literal(Constant(TypeErasure.erasure(tp)))
-      }
-    } else tree
-  }
+      val targ = tree.args.head.tpe
+      tree.clsOf(targ, Literal(Constant(TypeErasure.erasure(targ))))
+    }
+    else tree
 }
diff --git a/src/dotty/tools/dotc/transform/ClassTags.scala b/src/dotty/tools/dotc/transform/ClassTags.scala
index 9d8abae93..8fd25f785 100644
--- a/src/dotty/tools/dotc/transform/ClassTags.scala
+++ b/src/dotty/tools/dotc/transform/ClassTags.scala
@@ -31,9 +31,8 @@ class ClassTags extends MiniPhaseTransform with IdentityDenotTransformer { thisT
 
 
   override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): TreeTransform = {
-    val predefClass = defn.DottyPredefModule.moduleClass.asClass
-    classTagCache = ctx.requiredMethod(predefClass, nme.classTag)
-    typeTagCache = ctx.requiredMethod(predefClass, nme.typeTag)
+    classTagCache = defn.DottyPredefModule.requiredMethod(nme.classTag)
+    typeTagCache = defn.DottyPredefModule.requiredMethod(nme.typeTag)
     scala2ClassTagModule = ctx.requiredModule("scala.reflect.ClassTag")
     this
   }
@@ -45,20 +44,24 @@ class ClassTags extends MiniPhaseTransform with IdentityDenotTransformer { thisT
       val tp = tree.args.head.tpe
       val defn = ctx.definitions
       val (elemType, ndims) = tp match {
-        case defn.MultiArrayType(elem, ndims) => (elem, ndims)
+        case defn.MultiArrayOf(elem, ndims) => (elem, ndims)
         case _ => (tp, 0)
       }
 
       val claz = tp.classSymbol
       val elemClaz = elemType.classSymbol
       assert(!claz.isPrimitiveValueClass) // should be inserted by typer
-      val elemTag = if (defn.ScalaValueClasses.contains(elemClaz) || elemClaz == defn.NothingClass || elemClaz == defn.NullClass)
+      val elemTag = 
+        if (elemClaz.isPrimitiveValueClass || elemClaz == defn.NothingClass || elemClaz == defn.NullClass)
           ref(defn.DottyPredefModule).select(s"${elemClaz.name}ClassTag".toTermName)
-        else if (ValueClasses.isDerivedValueClass(elemClaz)) ref(claz.companionModule)
-        else if (elemClaz eq defn.AnyClass) ref(scala2ClassTagModule).select(nme.Any)
+        else if (ValueClasses.isDerivedValueClass(elemClaz)) 
+          ref(claz.companionModule)
+        else if (elemClaz eq defn.AnyClass) 
+          ref(scala2ClassTagModule).select(nme.Any)
         else {
           val erazedTp = TypeErasure.erasure(elemType).classSymbol.typeRef
-          ref(scala2ClassTagModule).select(nme.apply).appliedToType(erazedTp).appliedTo(Literal(Constant(erazedTp)))
+          ref(scala2ClassTagModule).select(nme.apply)
+            .appliedToType(erazedTp).appliedTo(Literal(Constant(erazedTp)))
         }
       (1 to ndims).foldLeft(elemTag)((arr, level) => Select(arr, nme.wrap).ensureApplied).ensureConforms(tree.tpe)
     } else tree
diff --git a/src/dotty/tools/dotc/transform/ElimByName.scala b/src/dotty/tools/dotc/transform/ElimByName.scala
index 2d0ecaf99..b65a46249 100644
--- a/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -120,7 +120,7 @@ class ElimByName extends MiniPhaseTransform with InfoTransformer { thisTransform
     else tree
 
   def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp match {
-    case ExprType(rt) if exprBecomesFunction(sym) => defn.FunctionType(Nil, rt)
+    case ExprType(rt) if exprBecomesFunction(sym) => defn.FunctionOf(Nil, rt)
     case _ => tp
   }
 
diff --git a/src/dotty/tools/dotc/transform/ElimRepeated.scala b/src/dotty/tools/dotc/transform/ElimRepeated.scala
index 9563a7ed0..98abbb26d 100644
--- a/src/dotty/tools/dotc/transform/ElimRepeated.scala
+++ b/src/dotty/tools/dotc/transform/ElimRepeated.scala
@@ -81,7 +81,7 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
         .select(nme.seqToArray)
         .appliedToType(elemType)
         .appliedTo(tree, Literal(Constant(elemClass.typeRef)))
-        .ensureConforms(defn.ArrayType(elemType))
+        .ensureConforms(defn.ArrayOf(elemType))
           // Because of phantomclasses, the Java array's type might not conform to the return type
   }
 
diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala
index a414c6399..1b9b898f2 100644
--- a/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/transform/Erasure.scala
@@ -119,10 +119,10 @@ object Erasure extends TypeTestsCasts{
   object Boxing {
 
     def isUnbox(sym: Symbol)(implicit ctx: Context) =
-      sym.name == nme.unbox && (defn.ScalaValueClasses contains sym.owner.linkedClass)
+      sym.name == nme.unbox && sym.owner.linkedClass.isPrimitiveValueClass
 
     def isBox(sym: Symbol)(implicit ctx: Context) =
-      sym.name == nme.box && (defn.ScalaValueClasses contains sym.owner.linkedClass)
+      sym.name == nme.box && sym.owner.linkedClass.isPrimitiveValueClass
 
     def boxMethod(cls: ClassSymbol)(implicit ctx: Context) =
       cls.linkedClass.info.member(nme.box).symbol
@@ -138,7 +138,7 @@ object Erasure extends TypeTestsCasts{
      */
     private def safelyRemovableUnboxArg(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case Apply(fn, arg :: Nil)
-      if isUnbox(fn.symbol) && (defn.ScalaBoxedClasses contains arg.tpe.widen.typeSymbol) =>
+      if isUnbox(fn.symbol) && defn.ScalaBoxedClasses().contains(arg.tpe.widen.typeSymbol) =>
         arg
       case _ =>
         EmptyTree
@@ -218,7 +218,7 @@ object Erasure extends TypeTestsCasts{
         case (JavaArrayType(treeElem), JavaArrayType(ptElem))
         if treeElem.widen.isPrimitiveValueType && !ptElem.isPrimitiveValueType =>
           // See SI-2386 for one example of when this might be necessary.
-          cast(ref(defn.runtimeMethod(nme.toObjectArray)).appliedTo(tree), pt)
+          cast(ref(defn.runtimeMethodRef(nme.toObjectArray)).appliedTo(tree), pt)
         case (_, ErasedValueType(cls, _)) =>
           ref(u2evt(cls)).appliedTo(tree)
         case _ =>
@@ -388,10 +388,10 @@ object Erasure extends TypeTestsCasts{
       }
 
     private def runtimeCallWithProtoArgs(name: Name, pt: Type, args: Tree*)(implicit ctx: Context): Tree = {
-      val meth = defn.runtimeMethod(name)
-      val followingParams = meth.info.firstParamTypes.drop(args.length)
+      val meth = defn.runtimeMethodRef(name)
+      val followingParams = meth.symbol.info.firstParamTypes.drop(args.length)
       val followingArgs = protoArgs(pt).zipWithConserve(followingParams)(typedExpr).asInstanceOf[List[tpd.Tree]]
-      ref(defn.runtimeMethod(name)).appliedToArgs(args.toList ++ followingArgs)
+      ref(meth).appliedToArgs(args.toList ++ followingArgs)
     }
 
     private def protoArgs(pt: Type): List[untpd.Tree] = pt match {
diff --git a/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
index 087e15c71..90e105ee7 100644
--- a/src/dotty/tools/dotc/transform/ExtensionMethods.scala
+++ b/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -76,9 +76,8 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
 
             val underlyingCls = underlying.classSymbol
             val underlyingClsName =
-              if (defn.ScalaNumericValueClasses.contains(underlyingCls) ||
-                underlyingCls == defn.BooleanClass) underlyingCls.name else nme.Object
-
+              if (underlyingCls.isNumericValueClass || underlyingCls == defn.BooleanClass) underlyingCls.name
+              else nme.Object
 
             val syp = ctx.requiredClass(s"dotty.runtime.vc.VC${underlyingClsName}Companion").asClass
 
@@ -98,9 +97,9 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
           moduleClassSym
       }
     case ref: SymDenotation
-    if isMethodWithExtension(ref) && ref.hasAnnotation(defn.TailrecAnnotationClass) =>
+    if isMethodWithExtension(ref) && ref.hasAnnotation(defn.TailrecAnnot) =>
       val ref1 = ref.copySymDenotation()
-      ref1.removeAnnotation(defn.TailrecAnnotationClass)
+      ref1.removeAnnotation(defn.TailrecAnnot)
       ref1
     case _ =>
       ref
diff --git a/src/dotty/tools/dotc/transform/FirstTransform.scala b/src/dotty/tools/dotc/transform/FirstTransform.scala
index aecc1b86f..3b629f9b6 100644
--- a/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -71,7 +71,7 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi
 
     def newCompanion(name: TermName, forClass: Symbol): Thicket = {
       val modul = ctx.newCompleteModuleSymbol(ctx.owner, name, Synthetic, Synthetic,
-        defn.ObjectClass.typeRef :: Nil, Scopes.newScope)
+        defn.ObjectType :: Nil, Scopes.newScope)
       val mc = modul.moduleClass
       if (ctx.owner.isClass) modul.enteredAfter(thisTransformer)
       ctx.synthesizeCompanionMethod(nme.COMPANION_CLASS_METHOD, forClass, mc).enteredAfter(thisTransformer)
@@ -100,7 +100,7 @@ class FirstTransform extends MiniPhaseTransform with IdentityDenotTransformer wi
     if (ddef.symbol.hasAnnotation(defn.NativeAnnot)) {
       ddef.symbol.resetFlag(Deferred)
       DefDef(ddef.symbol.asTerm,
-        _ => ref(defn.Sys_error).withPos(ddef.pos)
+        _ => ref(defn.Sys_errorR).withPos(ddef.pos)
           .appliedTo(Literal(Constant("native method stub"))))
     } else ddef
   }
diff --git a/src/dotty/tools/dotc/transform/GetClass.scala b/src/dotty/tools/dotc/transform/GetClass.scala
index 4d8c8ae40..9d182382d 100644
--- a/src/dotty/tools/dotc/transform/GetClass.scala
+++ b/src/dotty/tools/dotc/transform/GetClass.scala
@@ -4,7 +4,6 @@ package transform
 import ast.tpd
 import core.Contexts.Context
 import core.StdNames.nme
-import core.Symbols.TermSymbol
 import core.Phases.Phase
 import TreeTransforms.{MiniPhaseTransform, TransformerInfo}
 
@@ -24,25 +23,8 @@ class GetClass extends MiniPhaseTransform {
 
   override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = {
     import ast.Trees._
-
     tree match {
-      case Apply(Select(qual, nme.getClass_), Nil) =>
-        val defn = ctx.definitions
-        val claz = qual.tpe.widen.classSymbol
-
-        def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_).ensureConforms(tree.tpe)
-        claz match {
-          case defn.BooleanClass => TYPE(defn.BoxedBooleanModule)
-          case defn.ByteClass    => TYPE(defn.BoxedByteModule)
-          case defn.ShortClass   => TYPE(defn.BoxedShortModule)
-          case defn.CharClass    => TYPE(defn.BoxedCharModule)
-          case defn.IntClass     => TYPE(defn.BoxedIntModule)
-          case defn.LongClass    => TYPE(defn.BoxedLongModule)
-          case defn.FloatClass   => TYPE(defn.BoxedFloatModule)
-          case defn.DoubleClass  => TYPE(defn.BoxedDoubleModule)
-          case defn.UnitClass    => TYPE(defn.BoxedVoidModule)
-          case _                 => tree
-        }
+      case Apply(Select(qual, nme.getClass_), Nil) => tree.clsOf(qual.tpe.widen, tree)
       case _ => tree
     }
   }
diff --git a/src/dotty/tools/dotc/transform/InterceptedMethods.scala b/src/dotty/tools/dotc/transform/InterceptedMethods.scala
index ff354a54c..ffb4ae756 100644
--- a/src/dotty/tools/dotc/transform/InterceptedMethods.scala
+++ b/src/dotty/tools/dotc/transform/InterceptedMethods.scala
@@ -51,7 +51,7 @@ class InterceptedMethods extends MiniPhaseTransform {
   /** perform context-dependant initialization */
   override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
     this.Any_## = defn.Any_##
-    primitiveGetClassMethods = Set[Symbol]() ++ defn.ScalaValueClasses.map(x => x.requiredMethod(nme.getClass_))
+    primitiveGetClassMethods = Set[Symbol]() ++ defn.ScalaValueClasses().map(x => x.requiredMethod(nme.getClass_))
     this
   }
 
@@ -86,7 +86,7 @@ class InterceptedMethods extends MiniPhaseTransform {
       def alt2 = defn.ScalaRuntimeModule.info.member(nme.hash_)
         .suchThat(_.info.firstParamTypes.head.typeSymbol == defn.AnyClass)
 
-      Ident((if (defn.ScalaNumericValueClasses contains s) alt1 else alt2).termRef)
+      Ident((if (s.isNumericValueClass) alt1 else alt2).termRef)
         .appliedTo(tree)
     }
   }
diff --git a/src/dotty/tools/dotc/transform/NonLocalReturns.scala b/src/dotty/tools/dotc/transform/NonLocalReturns.scala
index 1f18a7318..7680e283e 100644
--- a/src/dotty/tools/dotc/transform/NonLocalReturns.scala
+++ b/src/dotty/tools/dotc/transform/NonLocalReturns.scala
@@ -29,7 +29,7 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer =>
 
   /** The type of a non-local return expression with given argument type */
   private def nonLocalReturnExceptionType(argtype: Type)(implicit ctx: Context) =
-    defn.NonLocalReturnControlClass.typeRef.appliedTo(argtype)
+    defn.NonLocalReturnControlType.appliedTo(argtype)
 
   /** A hashmap from method symbols to non-local return keys */
   private val nonLocalReturnKeys = mutable.Map[Symbol, TermSymbol]()
@@ -50,7 +50,7 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer =>
   private def nonLocalReturnThrow(expr: Tree, meth: Symbol)(implicit ctx: Context) =
     Throw(
       New(
-        defn.NonLocalReturnControlClass.typeRef,
+        defn.NonLocalReturnControlType,
         ref(nonLocalReturnKey(meth)) :: expr.ensureConforms(defn.ObjectType) :: Nil))
 
   /** Transform (body, key) to:
@@ -68,7 +68,7 @@ class NonLocalReturns extends MiniPhaseTransform { thisTransformer =>
    */
   private def nonLocalReturnTry(body: Tree, key: TermSymbol, meth: Symbol)(implicit ctx: Context) = {
     val keyDef = ValDef(key, New(defn.ObjectType, Nil))
-    val nonLocalReturnControl = defn.NonLocalReturnControlClass.typeRef
+    val nonLocalReturnControl = defn.NonLocalReturnControlType
     val ex = ctx.newSymbol(meth, nme.ex, EmptyFlags, nonLocalReturnControl, coord = body.pos)
     val pat = BindTyped(ex, nonLocalReturnControl)
     val rhs = If(
diff --git a/src/dotty/tools/dotc/transform/PatternMatcher.scala b/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 2df7a9825..5b4d42683 100644
--- a/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -134,7 +134,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
       // for name-based matching, but this was an expedient route for the basics.
       def drop(tgt: Tree)(n: Int): Tree = {
         def callDirect   = tgt.select(nme.drop).appliedTo(Literal(Constant(n)))
-        def callRuntime  = ref(defn.traversableDropMethod).appliedTo(tgt, Literal(Constant(n)))
+        def callRuntime  = ref(defn.ScalaRuntime_drop).appliedTo(tgt, Literal(Constant(n)))
 
         def needsRuntime = !(tgt.tpe derivesFrom defn.SeqClass) /*typeOfMemberNamedDrop(tgt.tpe) == NoType*/
 
@@ -755,7 +755,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
         def expectedWide            = expectedTp.widen
         def isAnyRef                = testedWide <:< defn.AnyRefType
         def isAsExpected            = testedWide <:< expectedTp
-        def isExpectedPrimitiveType = isAsExpected && defn.ScalaValueClasses.contains(expectedTp.classSymbol)
+        def isExpectedPrimitiveType = isAsExpected && expectedTp.classSymbol.isPrimitiveValueClass
         def isExpectedReferenceType = isAsExpected && (expectedTp <:< defn.AnyRefType)
         def mkNullTest              = nonNullTest(testedBinder)
         def mkOuterTest             = outerTest(testedBinder, expectedTp)
diff --git a/src/dotty/tools/dotc/transform/SyntheticMethods.scala b/src/dotty/tools/dotc/transform/SyntheticMethods.scala
index fa931a379..a496f80ce 100644
--- a/src/dotty/tools/dotc/transform/SyntheticMethods.scala
+++ b/src/dotty/tools/dotc/transform/SyntheticMethods.scala
@@ -77,7 +77,7 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
         coord = clazz.coord).enteredAfter(thisTransformer).asTerm
 
       def forwardToRuntime(vrefss: List[List[Tree]]): Tree =
-        ref(defn.runtimeMethod("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefss.head)
+        ref(defn.runtimeMethodRef("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefss.head)
 
       def syntheticRHS(implicit ctx: Context): List[List[Tree]] => Tree = synthetic.name match {
         case nme.hashCode_ if isDerivedValueClass(clazz) => vrefss => valueHashCodeBody
@@ -161,20 +161,17 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
     }
 
     /** The hashCode implementation for given symbol `sym`. */
-    def hashImpl(sym: Symbol)(implicit ctx: Context): Tree = {
-      val d = defn
-      import d._
-      sym.info.finalResultType.typeSymbol match {
-        case UnitClass | NullClass              => Literal(Constant(0))
-        case BooleanClass                       => If(ref(sym), Literal(Constant(1231)), Literal(Constant(1237)))
-        case IntClass                           => ref(sym)
-        case ShortClass | ByteClass | CharClass => ref(sym).select(nme.toInt)
-        case LongClass                          => ref(staticsMethod("longHash")).appliedTo(ref(sym))
-        case DoubleClass                        => ref(staticsMethod("doubleHash")).appliedTo(ref(sym))
-        case FloatClass                         => ref(staticsMethod("floatHash")).appliedTo(ref(sym))
-        case _                                  => ref(staticsMethod("anyHash")).appliedTo(ref(sym))
+    def hashImpl(sym: Symbol)(implicit ctx: Context): Tree =
+      defn.scalaClassName(sym.info.finalResultType) match {
+        case tpnme.Unit | tpnme.Null               => Literal(Constant(0))
+        case tpnme.Boolean                         => If(ref(sym), Literal(Constant(1231)), Literal(Constant(1237)))
+        case tpnme.Int                             => ref(sym)
+        case tpnme.Short | tpnme.Byte | tpnme.Char => ref(sym).select(nme.toInt)
+        case tpnme.Long                            => ref(defn.staticsMethod("longHash")).appliedTo(ref(sym))
+        case tpnme.Double                          => ref(defn.staticsMethod("doubleHash")).appliedTo(ref(sym))
+        case tpnme.Float                           => ref(defn.staticsMethod("floatHash")).appliedTo(ref(sym))
+        case _                                     => ref(defn.staticsMethod("anyHash")).appliedTo(ref(sym))
       }
-    }
 
     /** The class
      *
diff --git a/src/dotty/tools/dotc/transform/TailRec.scala b/src/dotty/tools/dotc/transform/TailRec.scala
index fdfb95e99..58fe7a6c9 100644
--- a/src/dotty/tools/dotc/transform/TailRec.scala
+++ b/src/dotty/tools/dotc/transform/TailRec.scala
@@ -85,7 +85,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
     tree match {
       case dd@DefDef(name, tparams, vparamss0, tpt, _)
         if (sym.isEffectivelyFinal) && !((sym is Flags.Accessor) || (dd.rhs eq EmptyTree) || (sym is Flags.Label)) =>
-        val mandatory = sym.hasAnnotation(defn.TailrecAnnotationClass)
+        val mandatory = sym.hasAnnotation(defn.TailrecAnnot)
         atGroupEnd { implicit ctx: Context =>
 
           cpy.DefDef(dd)(rhs = {
@@ -121,10 +121,10 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
             }
           })
         }
-      case d: DefDef if d.symbol.hasAnnotation(defn.TailrecAnnotationClass) =>
+      case d: DefDef if d.symbol.hasAnnotation(defn.TailrecAnnot) =>
         ctx.error("TailRec optimisation not applicable, method is neither private nor final so can be overridden", d.pos)
         d
-      case d if d.symbol.hasAnnotation(defn.TailrecAnnotationClass) =>
+      case d if d.symbol.hasAnnotation(defn.TailrecAnnot) =>
         ctx.error("TailRec optimisation not applicable, not a method", d.pos)
         d
       case _ => tree
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index 1f47b4486..0ee709539 100644
--- a/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -23,6 +23,7 @@ import ast.{tpd, untpd}
 import util.SourcePosition
 import collection.mutable
 import ProtoTypes._
+import config.Printers
 import java.lang.AssertionError
 import scala.util.control.NonFatal
 
@@ -79,7 +80,7 @@ class TreeChecker extends Phase with SymTransformer {
     val sym = symd.symbol
 
     if (sym.isClass && !sym.isAbsent) {
-      val validSuperclass = defn.ScalaValueClasses.contains(sym) ||  defn.syntheticCoreClasses.contains(sym) ||
+      val validSuperclass = sym.isPrimitiveValueClass ||  defn.syntheticCoreClasses.contains(sym) ||
         (sym eq defn.ObjectClass) || (sym is NoSuperClass) || (sym.asClass.superClass.exists)
       if (!validSuperclass)
         printError(s"$sym has no superclass set")
@@ -124,7 +125,10 @@ class TreeChecker extends Phase with SymTransformer {
     catch {
       case NonFatal(ex) =>
         implicit val ctx: Context = checkingCtx
-        ctx.println(i"*** error while checking after phase ${checkingCtx.phase.prev} ***")
+        ctx.println(i"*** error while checking ${ctx.compilationUnit} after phase ${checkingCtx.phase.prev} ***")
+        ctx.println(ex.toString)
+        ctx.println(ex.getStackTrace.take(30).deep.mkString("\n"))
+        ctx.println("<<<")
         throw ex
     }
   }
diff --git a/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index b2d45b661..c57d6fd1a 100644
--- a/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -50,7 +50,7 @@ trait TypeTestsCasts {
             Literal(Constant(true)) withPos tree.pos
           else if (argCls.isPrimitiveValueClass)
             if (qualCls.isPrimitiveValueClass) Literal(Constant(qualCls == argCls)) withPos tree.pos
-            else transformIsInstanceOf(expr, defn.boxedClass(argCls).typeRef)
+            else transformIsInstanceOf(expr, defn.boxedType(argCls.typeRef))
           else argType.dealias match {
             case _: SingletonType =>
               val cmpOp = if (argType derivesFrom defn.AnyValClass) defn.Any_equals else defn.Object_eq
@@ -68,9 +68,9 @@ trait TypeTestsCasts {
                     }
                 }
               }
-            case defn.MultiArrayType(elem, ndims) if isUnboundedGeneric(elem) =>
+            case defn.MultiArrayOf(elem, ndims) if isUnboundedGeneric(elem) =>
               def isArrayTest(arg: Tree) =
-                ref(defn.runtimeMethod(nme.isArray)).appliedTo(arg, Literal(Constant(ndims)))
+                ref(defn.runtimeMethodRef(nme.isArray)).appliedTo(arg, Literal(Constant(ndims)))
               if (ndims == 1) isArrayTest(qual)
               else evalOnce(qual) { qual1 =>
                 derivedTree(qual1, defn.Any_isInstanceOf, qual1.tpe) and isArrayTest(qual1)