diff --git a/src/dotty/tools/backend/jvm/CollectEntryPoints.scala b/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
index 80907fb996c5..3ed232bc7643 100644
--- a/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
+++ b/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
@@ -49,13 +49,10 @@ class CollectEntryPoints extends MiniPhaseTransform {
 
 object CollectEntryPoints{
   def isJavaMainMethod(sym: Symbol)(implicit ctx: Context) = {
-    val d = ctx.definitions
-    val StringType = d.StringType
-
     (sym.name == nme.main) && (sym.info match {
-      case r@MethodType(_, List(d.ArrayType(t))) =>
-        (t.widenDealias =:= StringType) && (
-        r.resultType.widenDealias =:= d.UnitType)
+      case r@MethodType(_, List(defn.ArrayOf(t))) =>
+        (t.widenDealias =:= defn.StringType) && (
+        r.resultType.widenDealias =:= defn.UnitType)
       case _ => false
     })
   }
diff --git a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index f92abe9060ef..1498be3546d5 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 = defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumNum)
+  lazy val externalEqualsNumChar: Symbol = ??? // ctx.requiredMethod(BoxesRunTimeTypeRef, nme.equalsNumChar) // this method is private
+  val externalEqualsNumObject: Symbol = defn.BoxesRunTimeModule.requiredMethod(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 FunctionClass: Array[Symbol] = defn.FunctionClassPerRun()
+  val AbstractFunctionClass: Array[Symbol] = defn.AbstractFunctionClassPerRun()
   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 = defn.ScalaPredefModule.requiredMethod(nme.classOf)
 
   lazy val AnnotationRetentionAttr = ctx.requiredClass("java.lang.annotation.Retention")
   lazy val AnnotationRetentionSourceAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE")
@@ -151,11 +148,10 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
   lazy val AnnotationRetentionRuntimeAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME")
   lazy val JavaAnnotationClass = ctx.requiredClass("java.lang.annotation.Annotation")
 
-
-  def boxMethods: Map[Symbol, Symbol] = defn.ScalaValueClasses.map{x =>
+  def boxMethods: Map[Symbol, Symbol] = defn.ScalaValueClasses().map{x => // @darkdimius Are you sure this should be a def?
     (x, Erasure.Boxing.boxMethod(x.asClass))
   }.toMap
-  def unboxMethods: Map[Symbol, Symbol] = defn.ScalaValueClasses.map(x => (x, Erasure.Boxing.unboxMethod(x.asClass))).toMap
+  def unboxMethods: Map[Symbol, Symbol] = defn.ScalaValueClasses().map(x => (x, Erasure.Boxing.unboxMethod(x.asClass))).toMap
 
   private val mkArrayNames: Set[Name] = Set("Byte", "Float", "Char", "Double", "Boolean", "Unit", "Long", "Int", "Short", "Ref").map{ x=>
     ("new" + x + "Array").toTermName
diff --git a/src/dotty/tools/backend/jvm/scalaPrimitives.scala b/src/dotty/tools/backend/jvm/scalaPrimitives.scala
index 8e742faf1952..0027defa7eeb 100644
--- a/src/dotty/tools/backend/jvm/scalaPrimitives.scala
+++ b/src/dotty/tools/backend/jvm/scalaPrimitives.scala
@@ -69,7 +69,7 @@ class DottyPrimitives(ctx: Context) {
     }
 
     def elementType: Type = tpe.widenDealias match {
-      case defn.ArrayType(el) => el
+      case defn.ArrayOf(el) => el
       case JavaArrayType(el) => el
       case _ =>
         ctx.error(s"expected Array $tpe")
@@ -79,42 +79,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 _                    => OARRAY_GET
+        defn.scalaClassName(elementType) match {
+          case tpnme.Boolean    => ZARRAY_GET
+          case tpnme.Byte       => BARRAY_GET
+          case tpnme.Short      => SARRAY_GET
+          case tpnme.Char       => CARRAY_GET
+          case tpnme.Int        => IARRAY_GET
+          case tpnme.Long       => LARRAY_GET
+          case tpnme.Float      => FARRAY_GET
+          case tpnme.Double     => 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
-          case _                    => OARRAY_SET
+        defn.scalaClassName(elementType) match {
+          case tpnme.Boolean    => ZARRAY_SET
+          case tpnme.Byte       => BARRAY_SET
+          case tpnme.Short      => SARRAY_SET
+          case tpnme.Char       => CARRAY_SET
+          case tpnme.Int        => IARRAY_SET
+          case tpnme.Long       => LARRAY_SET
+          case tpnme.Float      => FARRAY_SET
+          case tpnme.Double     => 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
-          case _                    => OARRAY_LENGTH
+        defn.scalaClassName(elementType) match {
+          case tpnme.Boolean    => ZARRAY_LENGTH
+          case tpnme.Byte       => BARRAY_LENGTH
+          case tpnme.Short      => SARRAY_LENGTH
+          case tpnme.Char       => CARRAY_LENGTH
+          case tpnme.Int        => IARRAY_LENGTH
+          case tpnme.Long       => LARRAY_LENGTH
+          case tpnme.Float      => FARRAY_LENGTH
+          case tpnme.Double     => DARRAY_LENGTH
+          case _                => OARRAY_LENGTH
         }
 
       case _ =>
diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala
index bf3dbb232bc3..4e96a6c8ab85 100644
--- a/src/dotty/tools/dotc/Compiler.scala
+++ b/src/dotty/tools/dotc/Compiler.scala
@@ -5,6 +5,7 @@ import core._
 import Contexts._
 import Periods._
 import Symbols._
+import Types._
 import Scopes._
 import typer.{FrontEnd, Typer, Mode, ImportInfo, RefChecks}
 import reporting.{Reporter, ConsoleReporter}
@@ -111,8 +112,8 @@ class Compiler {
       .setMode(Mode.ImplicitsEnabled)
       .setTyperState(new MutableTyperState(ctx.typerState, rootReporter(ctx), isCommittable = true))
     ctx.definitions.init(start) // set context of definitions to start
-    def addImport(ctx: Context, symf: () => Symbol) =
-      ctx.fresh.setImportInfo(ImportInfo.rootImport(symf)(ctx))
+    def addImport(ctx: Context, refFn: () => TermRef) =
+      ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
     (start.setRunInfo(new RunInfo(start)) /: defn.RootImportFns)(addImport)
   }
 
diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala
index 33205dfd4be6..6c914c934539 100644
--- a/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/src/dotty/tools/dotc/ast/Desugar.scala
@@ -323,7 +323,7 @@ object desugar {
 
     def anyRef = ref(defn.AnyRefAlias.typeRef)
     def productConstr(n: Int) = {
-      val tycon = ref(defn.ProductNClass(n).typeRef)
+      val tycon = scalaDot((tpnme.Product.toString + n).toTypeName)
       val targs = constrVparamss.head map (_.tpt)
       if (targs.isEmpty) tycon else AppliedTypeTree(tycon, targs)
     }
@@ -803,10 +803,10 @@ object desugar {
           makeBinop(l, op, r)
       case PostfixOp(t, op) =>
         if ((ctx.mode is Mode.Type) && op == nme.raw.STAR) {
-          val seqClass = if (ctx.compilationUnit.isJava) defn.ArrayClass else defn.SeqClass
+          val seqType = if (ctx.compilationUnit.isJava) defn.ArrayType else defn.SeqType
           Annotated(
-            New(ref(defn.RepeatedAnnot.typeRef), Nil :: Nil),
-            AppliedTypeTree(ref(seqClass.typeRef), t))
+            New(ref(defn.RepeatedAnnotType), Nil :: Nil),
+            AppliedTypeTree(ref(seqType), t))
         } else {
           assert(ctx.mode.isExpr || ctx.reporter.hasErrors, ctx.mode)
           Select(t, op)
@@ -818,22 +818,22 @@ object desugar {
       case Tuple(ts) =>
         if (unboxedPairs) {
           def PairTypeTree(l: Tree, r: Tree) =
-            AppliedTypeTree(ref(defn.PairClass.typeRef), l :: r :: Nil)
+            AppliedTypeTree(ref(defn.PairType), l :: r :: Nil)
           if (ctx.mode is Mode.Type) ts.reduceRight(PairTypeTree)
           else if (ts.isEmpty) unitLiteral
           else ts.reduceRight(Pair(_, _))
         }
         else {
           val arity = ts.length
-          def tupleClass = defn.TupleClass(arity)
+          def tupleTypeRef = defn.TupleType(arity)
           if (arity > Definitions.MaxTupleArity) {
             ctx.error(s"tuple too long (max allowed: ${Definitions.MaxTupleArity})", tree.pos)
             unitLiteral
           }
           else if (arity == 1) ts.head
-          else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleClass.typeRef), ts)
+          else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)
           else if (arity == 0) unitLiteral
-          else Apply(ref(tupleClass.companionModule.valRef), ts)
+          else Apply(ref(tupleTypeRef.classSymbol.companionModule.valRef), ts)
         }
       case WhileDo(cond, body) =>
         // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
diff --git a/src/dotty/tools/dotc/ast/TreeInfo.scala b/src/dotty/tools/dotc/ast/TreeInfo.scala
index 1266ebbd9658..2b0f0aee3e54 100644
--- a/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -230,7 +230,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
 
   /** Does this CaseDef catch Throwable? */
   def catchesThrowable(cdef: CaseDef)(implicit ctx: Context) =
-    catchesAllOf(cdef, defn.ThrowableClass.typeRef)
+    catchesAllOf(cdef, defn.ThrowableType)
 
   /** Does this CaseDef catch everything of a certain Type? */
   def catchesAllOf(cdef: CaseDef, threshold: Type)(implicit ctx: Context) =
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 14a36f39848c..feeaad49dc36 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package ast
 
-import dotty.tools.dotc.transform.ExplicitOuter
+import dotty.tools.dotc.transform.{ExplicitOuter, Erasure}
 import dotty.tools.dotc.typer.ProtoTypes.FunProtoTyped
 import transform.SymUtils._
 import core._
@@ -13,7 +13,6 @@ import config.Printers._
 import typer.Mode
 import collection.mutable
 import typer.ErrorReporting._
-import transform.Erasure
 
 import scala.annotation.tailrec
 
@@ -268,7 +267,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(implicit ctx: Context): Block = {
     val owner = fns.head.owner
     val parents1 =
-      if (parents.head.classSymbol.is(Trait)) defn.ObjectClass.typeRef :: parents
+      if (parents.head.classSymbol.is(Trait)) defn.ObjectType :: parents
       else parents
     val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_FUN, Synthetic, parents1,
         coord = fns.map(_.pos).reduceLeft(_ union _))
@@ -376,7 +375,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       newArr(elemClass.name.toString)
     else
       newArr("Ref").appliedToTypeTrees(
-        TypeTree(defn.ArrayType(elemType)).withPos(typeArg.pos) :: Nil)
+        TypeTree(defn.ArrayOf(elemType)).withPos(typeArg.pos) :: Nil)
   }
 
   // ------ Creating typed equivalents of trees that exist only in untyped form -------
@@ -778,6 +777,27 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
       else Assign(tree, rhs)
 
+    /** A tree in place of this tree that represents the class of type `tp`.
+     *  Contains special handling if the class is a primitive value class
+     *  and invokes a `default` method otherwise.
+     */
+    def clsOf(tp: Type, default: => Tree)(implicit ctx: Context): Tree = {
+      def TYPE(module: TermSymbol) =
+        ref(module).select(nme.TYPE_).ensureConforms(tree.tpe).withPos(tree.pos)
+      defn.scalaClassName(tp) match {
+        case tpnme.Boolean => TYPE(defn.BoxedBooleanModule)
+        case tpnme.Byte => TYPE(defn.BoxedByteModule)
+        case tpnme.Short => TYPE(defn.BoxedShortModule)
+        case tpnme.Char => TYPE(defn.BoxedCharModule)
+        case tpnme.Int => TYPE(defn.BoxedIntModule)
+        case tpnme.Long => TYPE(defn.BoxedLongModule)
+        case tpnme.Float => TYPE(defn.BoxedFloatModule)
+        case tpnme.Double => TYPE(defn.BoxedDoubleModule)
+        case tpnme.Unit => TYPE(defn.BoxedUnitModule)
+        case _ => default
+      }
+    }
+
     // --- Higher order traversal methods -------------------------------
 
     /** Apply `f` to each subtree of this tree */
@@ -843,14 +863,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         val defn = ctx.definitions
         val prefix = args.take(selected.widen.paramTypess.head.size - 1)
         expectedType match {
-          case defn.ArrayType(el) =>
+          case defn.ArrayOf(el) =>
             lastParam.tpe match {
-              case defn.ArrayType(el2) if el2 <:< el =>
+              case defn.ArrayOf(el2) if el2 <:< el =>
                 // we have a JavaSeqLiteral with a more precise type
                 // we cannot construct a tree as JavaSeqLiteral infered to precise type
                 // if we add typed than it would be both type-correct and
                 // will pass Ycheck
-                prefix ::: List(tpd.Typed(lastParam, TypeTree(defn.ArrayType(el))))
+                prefix ::: List(tpd.Typed(lastParam, TypeTree(defn.ArrayOf(el))))
               case _ =>
                 ???
             }
diff --git a/src/dotty/tools/dotc/ast/untpd.scala b/src/dotty/tools/dotc/ast/untpd.scala
index 5db893ff2f9d..28a3cf1ff405 100644
--- a/src/dotty/tools/dotc/ast/untpd.scala
+++ b/src/dotty/tools/dotc/ast/untpd.scala
@@ -201,7 +201,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def ref(tp: NamedType)(implicit ctx: Context): Tree =
     TypedSplice(tpd.ref(tp))
 
-  def scalaUnit(implicit ctx: Context) = ref(defn.UnitClass.typeRef)
+  def rootDot(name: Name) = Select(Ident(nme.ROOTPKG), name)
+  def scalaDot(name: Name) = Select(rootDot(nme.scala_), name)
+  def scalaUnit = scalaDot(tpnme.Unit)
 
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef =
     DefDef(nme.CONSTRUCTOR, tparams, vparamss, TypeTree(), rhs)
diff --git a/src/dotty/tools/dotc/config/JavaPlatform.scala b/src/dotty/tools/dotc/config/JavaPlatform.scala
index 41a9c7113366..432a9a0b7474 100644
--- a/src/dotty/tools/dotc/config/JavaPlatform.scala
+++ b/src/dotty/tools/dotc/config/JavaPlatform.scala
@@ -19,13 +19,11 @@ class JavaPlatform extends Platform {
   }
 
   // The given symbol is a method with the right name and signature to be a runnable java program.
-  def isJavaMainMethod(sym: SymDenotation)(implicit ctx: Context) = {
-    val dn = defn
+  def isJavaMainMethod(sym: SymDenotation)(implicit ctx: Context) =
     (sym.name == nme.main) && (sym.info match {
-      case t@MethodType(_, dn.ArrayType(el) :: Nil) => el =:= defn.StringType && (t.resultType isRef defn.UnitClass)
+      case t@MethodType(_, defn.ArrayOf(el) :: Nil) => el =:= defn.StringType && (t.resultType isRef defn.UnitClass)
       case _ => false
     })
-  }
 
   // The given class has a main method.
   def hasJavaMainMethod(sym: Symbol)(implicit ctx: Context): Boolean =
diff --git a/src/dotty/tools/dotc/config/Printers.scala b/src/dotty/tools/dotc/config/Printers.scala
index b44a1d2f6b5c..8b9cc45c4ce4 100644
--- a/src/dotty/tools/dotc/config/Printers.scala
+++ b/src/dotty/tools/dotc/config/Printers.scala
@@ -22,13 +22,13 @@ object Printers {
   val implicitsDetailed: Printer = noPrinter
   val subtyping: Printer = noPrinter
   val unapp: Printer = noPrinter
-  val completions = noPrinter
   val gadts = noPrinter
   val hk = noPrinter
   val variances = noPrinter
   val incremental = noPrinter
   val config = noPrinter
   val transforms = noPrinter
+  val completions = noPrinter
   val cyclicErrors = noPrinter
   val pickling = noPrinter
 }
diff --git a/src/dotty/tools/dotc/core/Annotations.scala b/src/dotty/tools/dotc/core/Annotations.scala
index 6d0fba33708d..b9c0eca43583 100644
--- a/src/dotty/tools/dotc/core/Annotations.scala
+++ b/src/dotty/tools/dotc/core/Annotations.scala
@@ -91,12 +91,12 @@ object Annotations {
 
     def makeChild(sym: Symbol)(implicit ctx: Context) =
       deferred(defn.ChildAnnot,
-        implicit ctx => New(defn.ChildAnnot.typeRef.appliedTo(sym.owner.thisType.select(sym.name, sym)), Nil))
+        implicit ctx => New(defn.ChildAnnotType.appliedTo(sym.owner.thisType.select(sym.name, sym)), Nil))
   }
 
   def ThrowsAnnotation(cls: ClassSymbol)(implicit ctx: Context) = {
     val tref = cls.typeRef
-    Annotation(defn.ThrowsAnnot.typeRef.appliedTo(tref), Ident(tref))
+    Annotation(defn.ThrowsAnnotType.appliedTo(tref), Ident(tref))
   }
 
   /** A decorator that provides queries for specific annotations
diff --git a/src/dotty/tools/dotc/core/Constants.scala b/src/dotty/tools/dotc/core/Constants.scala
index 61a23bb9e33e..e13e07f5881b 100644
--- a/src/dotty/tools/dotc/core/Constants.scala
+++ b/src/dotty/tools/dotc/core/Constants.scala
@@ -54,17 +54,17 @@ object Constants {
     def isAnyVal              = UnitTag <= tag && tag <= DoubleTag
 
     def tpe(implicit ctx: Context): Type = tag match {
-      case UnitTag    => defn.UnitClass.typeRef
-      case BooleanTag => defn.BooleanClass.typeRef
-      case ByteTag    => defn.ByteClass.typeRef
-      case ShortTag   => defn.ShortClass.typeRef
-      case CharTag    => defn.CharClass.typeRef
-      case IntTag     => defn.IntClass.typeRef
-      case LongTag    => defn.LongClass.typeRef
-      case FloatTag   => defn.FloatClass.typeRef
-      case DoubleTag  => defn.DoubleClass.typeRef
-      case StringTag  => defn.StringClass.typeRef
-      case NullTag    => defn.NullClass.typeRef
+      case UnitTag    => defn.UnitType
+      case BooleanTag => defn.BooleanType
+      case ByteTag    => defn.ByteType
+      case ShortTag   => defn.ShortType
+      case CharTag    => defn.CharType
+      case IntTag     => defn.IntType
+      case LongTag    => defn.LongType
+      case FloatTag   => defn.FloatType
+      case DoubleTag  => defn.DoubleType
+      case StringTag  => defn.StringType
+      case NullTag    => defn.NullType
       case ClazzTag   => defn.ClassType(typeValue)
       case EnumTag    => defn.EnumType(symbolValue)
     }
diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala
index 6f322904ee98..433b8544afd0 100644
--- a/src/dotty/tools/dotc/core/Definitions.scala
+++ b/src/dotty/tools/dotc/core/Definitions.scala
@@ -3,7 +3,7 @@ package dotc
 package core
 
 import Types._, Contexts._, Symbols._, Denotations._, SymDenotations._, StdNames._, Names._
-import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._
+import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._, Periods._
 import unpickleScala2.Scala2Unpickler.ensureConstructor
 import scala.annotation.{ switch, meta }
 import scala.collection.{ mutable, immutable }
@@ -15,7 +15,21 @@ object Definitions {
   val MaxFunctionArity, MaxTupleArity = 22
 }
 
-/** A class defining symbols and types of standard definitions */
+/** A class defining symbols and types of standard definitions
+ *
+ *  Note: There's a much nicer design possible once we have implicit functions.
+ *  The idea is explored to some degree in branch wip-definitions (#929): Instead of a type
+ *  and a separate symbol definition, we produce in one line an implicit function from
+ *  Context to Symbol, and possibly also the corresponding type. This cuts down on all
+ *  the duplication encountered here.
+ *
+ *  wip-definitions tries to do the same with an implicit conversion from a SymbolPerRun
+ *  type to a symbol type. The problem with that is universal equality. Comparisons will
+ *  not trigger the conversion and will therefore likely return false results.
+ *
+ *  So the branch is put on hold, until we have implicit functions, which will always
+ *  automatically be dereferenced.
+ */
 class Definitions {
   import Definitions._
 
@@ -82,9 +96,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 +128,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 = SysPackage.moduleClass.requiredMethodRef(nme.error)
+    def Sys_error(implicit ctx: Context) = 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
@@ -139,7 +154,9 @@ class Definitions {
    *     }
    */
   lazy val AnyClass: ClassSymbol = completeClass(newCompleteClassSymbol(ScalaPackageClass, tpnme.Any, Abstract, Nil))
+  def AnyType = AnyClass.typeRef
   lazy val AnyValClass: ClassSymbol = completeClass(newCompleteClassSymbol(ScalaPackageClass, tpnme.AnyVal, Abstract, List(AnyClass.typeRef)))
+  def AnyValType = AnyValClass.typeRef
 
     lazy val Any_==       = newMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
     lazy val Any_!=       = newMethod(AnyClass, nme.NE, methOfAny(BooleanType), Final)
@@ -160,7 +177,10 @@ class Definitions {
     cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope)
     completeClass(cls)
   }
+  def ObjectType = ObjectClass.typeRef
+
   lazy val AnyRefAlias: TypeSymbol = newAliasType(tpnme.AnyRef, ObjectType)
+  def AnyRefType = AnyRefAlias.typeRef
 
     lazy val Object_eq = newMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
     lazy val Object_ne = newMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
@@ -180,7 +200,7 @@ class Definitions {
   /** Dummy method needed by elimByName */
   lazy val dummyApply = newPolyMethod(
       OpsPackageClass, nme.dummyApply, 1,
-      pt => MethodType(List(FunctionType(Nil, PolyParam(pt, 0))), PolyParam(pt, 0)))
+      pt => MethodType(List(FunctionOf(Nil, PolyParam(pt, 0))), PolyParam(pt, 0)))
 
   /** Method representing a throw */
   lazy val throwMethod = newMethod(OpsPackageClass, nme.THROWkw,
@@ -188,90 +208,140 @@ class Definitions {
 
   lazy val NothingClass: ClassSymbol = newCompleteClassSymbol(
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
+  def NothingType = NothingClass.typeRef
   lazy val NullClass: ClassSymbol = newCompleteClassSymbol(
     ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef))
+  def NullType = NullClass.typeRef
 
-  lazy val ScalaPredefModule = ctx.requiredModule("scala.Predef")
+  lazy val ScalaPredefModuleRef = ctx.requiredModuleRef("scala.Predef")
+  def ScalaPredefModule(implicit ctx: Context) = ScalaPredefModuleRef.symbol
 
-    lazy val Predef_conforms = ctx.requiredMethod(ScalaPredefModule.moduleClass.asClass, "$conforms")
+    lazy val Predef_conformsR = ScalaPredefModule.requiredMethodRef("$conforms")
+    def Predef_conforms(implicit ctx: Context) = 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(implicit ctx: Context) = ScalaRuntimeModuleRef.symbol
+  def ScalaRuntimeClass(implicit ctx: Context) = ScalaRuntimeModule.moduleClass.asClass
 
-    def runtimeMethod(name: PreName) = ctx.requiredMethod(ScalaRuntimeClass, name)
+    def runtimeMethodRef(name: PreName) = ScalaRuntimeModule.requiredMethodRef(name)
+    def ScalaRuntime_dropR(implicit ctx: Context) = runtimeMethodRef(nme.drop)
+    def ScalaRuntime_drop(implicit ctx: Context) = 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(implicit ctx: Context) = BoxesRunTimeModuleRef.symbol
+  def BoxesRunTimeClass(implicit ctx: Context) = BoxesRunTimeModule.moduleClass.asClass
+  lazy val ScalaStaticsModuleRef = ctx.requiredModuleRef("scala.runtime.Statics")
+  def ScalaStaticsModule(implicit ctx: Context) = ScalaStaticsModuleRef.symbol
+  def ScalaStaticsClass(implicit ctx: Context) = ScalaStaticsModule.moduleClass.asClass
 
-    def staticsMethod(name: PreName) = ctx.requiredMethod(ScalaStaticsClass, name)
+    def staticsMethodRef(name: PreName) = ScalaStaticsModule.requiredMethodRef(name)
+    def staticsMethod(name: PreName) = ScalaStaticsModule.requiredMethod(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(implicit ctx: Context) = DottyPredefModuleRef.symbol
+  lazy val DottyArraysModuleRef = ctx.requiredModuleRef("dotty.runtime.Arrays")
+  def DottyArraysModule(implicit ctx: Context) = DottyArraysModuleRef.symbol
 
-    def newRefArrayMethod = ctx.requiredMethod(DottyArraysModule.moduleClass.asClass, "newRefArray")
+    def newRefArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newRefArray")
 
-  lazy val NilModule = ctx.requiredModule("scala.collection.immutable.Nil")
+  lazy val NilModuleRef = ctx.requiredModuleRef("scala.collection.immutable.Nil")
+  def NilModule(implicit ctx: Context) = NilModuleRef.symbol
 
-//  lazy val FunctionClass: ClassSymbol = ctx.requiredClass("scala.Function")
   lazy val SingletonClass: ClassSymbol =
     // needed as a synthetic class because Scala 2.x refers to it in classfiles
     // but does not define it as an explicit class.
     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 SeqType: TypeRef = ctx.requiredClassRef("scala.collection.Seq")
+  def SeqClass(implicit ctx: Context) = SeqType.symbol.asClass
+
+    lazy val Seq_applyR = SeqClass.requiredMethodRef(nme.apply)
+    def Seq_apply(implicit ctx: Context) = Seq_applyR.symbol
+    lazy val Seq_headR = SeqClass.requiredMethodRef(nme.head)
+    def Seq_head(implicit ctx: Context) = Seq_headR.symbol
+
+  lazy val ArrayType: TypeRef = ctx.requiredClassRef("scala.Array")
+  def ArrayClass(implicit ctx: Context) = ArrayType.symbol.asClass
+    lazy val Array_applyR                 = ArrayClass.requiredMethodRef(nme.apply)
+    def Array_apply(implicit ctx: Context) = Array_applyR.symbol
+    lazy val Array_updateR                = ArrayClass.requiredMethodRef(nme.update)
+    def Array_update(implicit ctx: Context) = Array_updateR.symbol
+    lazy val Array_lengthR                = ArrayClass.requiredMethodRef(nme.length)
+    def Array_length(implicit ctx: Context) = Array_lengthR.symbol
+    lazy val Array_cloneR                 = ArrayClass.requiredMethodRef(nme.clone_)
+    def Array_clone(implicit ctx: Context) = Array_cloneR.symbol
+    lazy val ArrayConstructorR            = ArrayClass.requiredMethodRef(nme.CONSTRUCTOR)
+    def ArrayConstructor(implicit ctx: Context) = ArrayConstructorR.symbol
+
+  lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", BoxedUnitType, java.lang.Void.TYPE, UnitEnc)
+  def UnitClass(implicit ctx: Context) = UnitType.symbol.asClass
+  lazy val BooleanType = valueTypeRef("scala.Boolean", BoxedBooleanType, java.lang.Boolean.TYPE, BooleanEnc)
+  def BooleanClass(implicit ctx: Context) = BooleanType.symbol.asClass
+    lazy val Boolean_notR   = BooleanClass.requiredMethodRef(nme.UNARY_!)
+    def Boolean_! = Boolean_notR.symbol
+    lazy val Boolean_andR = BooleanClass.requiredMethodRef(nme.ZAND) // ### harmonize required... calls
+    def Boolean_&& = Boolean_andR.symbol
+    lazy val Boolean_orR  = BooleanClass.requiredMethodRef(nme.ZOR)
+    def Boolean_|| = Boolean_orR.symbol
+
+  lazy val ByteType: TypeRef = valueTypeRef("scala.Byte", BoxedByteType, java.lang.Byte.TYPE, ByteEnc)
+  def ByteClass(implicit ctx: Context) = ByteType.symbol.asClass
+  lazy val ShortType: TypeRef = valueTypeRef("scala.Short", BoxedShortType, java.lang.Short.TYPE, ShortEnc)
+  def ShortClass(implicit ctx: Context) = ShortType.symbol.asClass
+  lazy val CharType: TypeRef = valueTypeRef("scala.Char", BoxedCharType, java.lang.Character.TYPE, CharEnc)
+  def CharClass(implicit ctx: Context) = CharType.symbol.asClass
+  lazy val IntType: TypeRef = valueTypeRef("scala.Int", BoxedIntType, java.lang.Integer.TYPE, IntEnc)
+  def IntClass(implicit ctx: Context) = IntType.symbol.asClass
+    lazy val Int_minusR   = IntClass.requiredMethodRef(nme.MINUS, List(IntType))
+    def Int_- = Int_minusR.symbol
+    lazy val Int_plusR   = IntClass.requiredMethodRef(nme.PLUS, List(IntType))
+    def Int_+ = Int_plusR.symbol
+    lazy val Int_divR   = IntClass.requiredMethodRef(nme.DIV, List(IntType))
+    def Int_/ = Int_divR.symbol
+    lazy val Int_mulR   = IntClass.requiredMethodRef(nme.MUL, List(IntType))
+    def Int_* = Int_mulR.symbol
+    lazy val Int_eqR   = IntClass.requiredMethodRef(nme.EQ, List(IntType))
+    def Int_== = Int_eqR.symbol
+    lazy val Int_geR   = IntClass.requiredMethodRef(nme.GE, List(IntType))
+    def Int_>= = Int_geR.symbol
+    lazy val Int_leR   = IntClass.requiredMethodRef(nme.LE, List(IntType))
+    def Int_<= = Int_leR.symbol
+  lazy val LongType: TypeRef = valueTypeRef("scala.Long", BoxedLongType, java.lang.Long.TYPE, LongEnc)
+  def LongClass(implicit ctx: Context) = LongType.symbol.asClass
+    lazy val Long_XOR_Long = LongType.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 = LongType.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 FloatType: TypeRef = valueTypeRef("scala.Float", BoxedFloatType, java.lang.Float.TYPE, FloatEnc)
+  def FloatClass(implicit ctx: Context) = FloatType.symbol.asClass
+  lazy val DoubleType: TypeRef = valueTypeRef("scala.Double", BoxedDoubleType, java.lang.Double.TYPE, DoubleEnc)
+  def DoubleClass(implicit ctx: Context) = DoubleType.symbol.asClass
+
+  lazy val BoxedUnitType: TypeRef = ctx.requiredClassRef("scala.runtime.BoxedUnit")
+  def BoxedUnitClass(implicit ctx: Context) = BoxedUnitType.symbol.asClass
+
+    def BoxedUnit_UNIT(implicit ctx: Context) = BoxedUnitClass.linkedClass.requiredValue("UNIT")
+
+  lazy val BoxedBooleanType: TypeRef = ctx.requiredClassRef("java.lang.Boolean")
+  def BoxedBooleanClass(implicit ctx: Context) = BoxedBooleanType.symbol.asClass
+  lazy val BoxedByteType: TypeRef = ctx.requiredClassRef("java.lang.Byte")
+  def BoxedByteClass(implicit ctx: Context) = BoxedByteType.symbol.asClass
+  lazy val BoxedShortType: TypeRef = ctx.requiredClassRef("java.lang.Short")
+  def BoxedShortClass(implicit ctx: Context) = BoxedShortType.symbol.asClass
+  lazy val BoxedCharType: TypeRef = ctx.requiredClassRef("java.lang.Character")
+  def BoxedCharClass(implicit ctx: Context) = BoxedCharType.symbol.asClass
+  lazy val BoxedIntType: TypeRef = ctx.requiredClassRef("java.lang.Integer")
+  def BoxedIntClass(implicit ctx: Context) = BoxedIntType.symbol.asClass
+  lazy val BoxedLongType: TypeRef = ctx.requiredClassRef("java.lang.Long")
+  def BoxedLongClass(implicit ctx: Context) = BoxedLongType.symbol.asClass
+  lazy val BoxedFloatType: TypeRef = ctx.requiredClassRef("java.lang.Float")
+  def BoxedFloatClass(implicit ctx: Context) = BoxedFloatType.symbol.asClass
+  lazy val BoxedDoubleType: TypeRef = ctx.requiredClassRef("java.lang.Double")
+  def BoxedDoubleClass(implicit ctx: Context) = BoxedDoubleType.symbol.asClass
 
   lazy val BoxedBooleanModule = ctx.requiredModule("java.lang.Boolean")
   lazy val BoxedByteModule    = ctx.requiredModule("java.lang.Byte")
@@ -281,7 +351,7 @@ class Definitions {
   lazy val BoxedLongModule    = ctx.requiredModule("java.lang.Long")
   lazy val BoxedFloatModule   = ctx.requiredModule("java.lang.Float")
   lazy val BoxedDoubleModule  = ctx.requiredModule("java.lang.Double")
-  lazy val BoxedVoidModule    = ctx.requiredModule("java.lang.Void")
+  lazy val BoxedUnitModule    = ctx.requiredModule("java.lang.Void")
 
   lazy val ByNameParamClass2x     = specialPolyClass(tpnme.BYNAME_PARAM_CLASS, Covariant, AnyType)
   lazy val EqualsPatternClass     = specialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, AnyType)
@@ -289,8 +359,9 @@ 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")
+  def StringType: Type                = StringClass.typeRef
+  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 +369,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 SerializableType: TypeRef       = ctx.requiredClassRef("scala.Serializable")
+  def SerializableClass(implicit ctx: Context) = SerializableType.symbol.asClass
+  lazy val StringBuilderType: TypeRef      = ctx.requiredClassRef("scala.collection.mutable.StringBuilder")
+  def StringBuilderClass(implicit ctx: Context) = StringBuilderType.symbol.asClass
+  lazy val MatchErrorType: TypeRef         = ctx.requiredClassRef("scala.MatchError")
+  def MatchErrorClass(implicit ctx: Context) = MatchErrorType.symbol.asClass
+
+  lazy val StringAddType: TypeRef          = ctx.requiredClassRef("scala.runtime.StringAdd")
+  def StringAddClass(implicit ctx: Context) = StringAddType.symbol.asClass
+
+    lazy val StringAdd_plusR = StringAddClass.requiredMethodRef(nme.raw.PLUS)
+    def StringAdd_+(implicit ctx: Context) = StringAdd_plusR.symbol
+
+  lazy val PairType: TypeRef                    = ctx.requiredClassRef("dotty.Pair")
+  def PairClass(implicit ctx: Context) = PairType.symbol.asClass
+  lazy val PartialFunctionType: TypeRef         = ctx.requiredClassRef("scala.PartialFunction")
+  def PartialFunctionClass(implicit ctx: Context) = PartialFunctionType.symbol.asClass
+  lazy val AbstractPartialFunctionType: TypeRef = ctx.requiredClassRef("scala.runtime.AbstractPartialFunction")
+  def AbstractPartialFunctionClass(implicit ctx: Context) = AbstractPartialFunctionType.symbol.asClass
+  lazy val SymbolType: TypeRef                  = ctx.requiredClassRef("scala.Symbol")
+  def SymbolClass(implicit ctx: Context) = SymbolType.symbol.asClass
+  lazy val DynamicType: TypeRef                 = ctx.requiredClassRef("scala.Dynamic")
+  def DynamicClass(implicit ctx: Context) = DynamicType.symbol.asClass
+  lazy val OptionType: TypeRef                  = ctx.requiredClassRef("scala.Option")
+  def OptionClass(implicit ctx: Context) = OptionType.symbol.asClass
+  lazy val ProductType: TypeRef                 = ctx.requiredClassRef("scala.Product")
+  def ProductClass(implicit ctx: Context) = ProductType.symbol.asClass
+    lazy val Product_canEqualR = ProductClass.requiredMethodRef(nme.canEqual_)
+    def Product_canEqual(implicit ctx: Context) = Product_canEqualR.symbol
+    lazy val Product_productArityR = ProductClass.requiredMethodRef(nme.productArity)
+    def Product_productArity(implicit ctx: Context) = Product_productArityR.symbol
+    lazy val Product_productPrefixR = ProductClass.requiredMethodRef(nme.productPrefix)
+    def Product_productPrefix(implicit ctx: Context) = Product_productPrefixR.symbol
+  lazy val LanguageModuleRef          = ctx.requiredModule("dotty.language")
+  def LanguageModuleClass(implicit ctx: Context) = LanguageModuleRef.symbol.moduleClass.asClass
+  lazy val NonLocalReturnControlType: TypeRef   = 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 AnnotationType              = ctx.requiredClassRef("scala.annotation.Annotation")
+  def AnnotationClass(implicit ctx: Context) = AnnotationType.symbol.asClass
+  lazy val ClassfileAnnotationType     = ctx.requiredClassRef("scala.annotation.ClassfileAnnotation")
+  def ClassfileAnnotationClass(implicit ctx: Context) = ClassfileAnnotationType.symbol.asClass
+  lazy val StaticAnnotationType        = ctx.requiredClassRef("scala.annotation.StaticAnnotation")
+  def StaticAnnotationClass(implicit ctx: Context) = StaticAnnotationType.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 AliasAnnotType = ctx.requiredClassRef("dotty.annotation.internal.Alias")
+  def AliasAnnot(implicit ctx: Context) = AliasAnnotType.symbol.asClass
+  lazy val AnnotationDefaultAnnotType = ctx.requiredClassRef("dotty.annotation.internal.AnnotationDefault")
+  def AnnotationDefaultAnnot(implicit ctx: Context) = AnnotationDefaultAnnotType.symbol.asClass
+  lazy val ChildAnnotType = ctx.requiredClassRef("dotty.annotation.internal.Child")
+  def ChildAnnot(implicit ctx: Context) = ChildAnnotType.symbol.asClass
+  lazy val CovariantBetweenAnnotType = ctx.requiredClassRef("dotty.annotation.internal.CovariantBetween")
+  def CovariantBetweenAnnot(implicit ctx: Context) = CovariantBetweenAnnotType.symbol.asClass
+  lazy val ContravariantBetweenAnnotType = ctx.requiredClassRef("dotty.annotation.internal.ContravariantBetween")
+  def ContravariantBetweenAnnot(implicit ctx: Context) = ContravariantBetweenAnnotType.symbol.asClass
+  lazy val DeprecatedAnnotType = ctx.requiredClassRef("scala.deprecated")
+  def DeprecatedAnnot(implicit ctx: Context) = DeprecatedAnnotType.symbol.asClass
+  lazy val InvariantBetweenAnnotType = ctx.requiredClassRef("dotty.annotation.internal.InvariantBetween")
+  def InvariantBetweenAnnot(implicit ctx: Context) = InvariantBetweenAnnotType.symbol.asClass
+  lazy val MigrationAnnotType = ctx.requiredClassRef("scala.annotation.migration")
+  def MigrationAnnot(implicit ctx: Context) = MigrationAnnotType.symbol.asClass
+  lazy val NativeAnnotType                   = ctx.requiredClassRef("scala.native")
+  def NativeAnnot(implicit ctx: Context) = NativeAnnotType.symbol.asClass
+  lazy val RemoteAnnotType                   = ctx.requiredClassRef("scala.remote")
+  def RemoteAnnot(implicit ctx: Context) = RemoteAnnotType.symbol.asClass
+  lazy val RepeatedAnnotType = ctx.requiredClassRef("dotty.annotation.internal.Repeated")
+  def RepeatedAnnot(implicit ctx: Context) = RepeatedAnnotType.symbol.asClass
+  lazy val ScalaSignatureAnnotType = ctx.requiredClassRef("scala.reflect.ScalaSignature")
+  def ScalaSignatureAnnot(implicit ctx: Context) = ScalaSignatureAnnotType.symbol.asClass
+  lazy val ScalaLongSignatureAnnotType = ctx.requiredClassRef("scala.reflect.ScalaLongSignature")
+  def ScalaLongSignatureAnnot(implicit ctx: Context) = ScalaLongSignatureAnnotType.symbol.asClass
+  lazy val ScalaStrictFPAnnotType            = ctx.requiredClassRef("scala.annotation.strictfp")
+  def ScalaStrictFPAnnot(implicit ctx: Context) = ScalaStrictFPAnnotType.symbol.asClass
+  lazy val SerialVersionUIDAnnotType         = ctx.requiredClassRef("scala.SerialVersionUID")
+  def SerialVersionUIDAnnot(implicit ctx: Context) = SerialVersionUIDAnnotType.symbol.asClass
+  lazy val TASTYSignatureAnnotType = ctx.requiredClassRef("scala.annotation.internal.TASTYSignature")
+  def TASTYSignatureAnnot(implicit ctx: Context) = TASTYSignatureAnnotType.symbol.asClass
+  lazy val TASTYLongSignatureAnnotType = ctx.requiredClassRef("scala.annotation.internal.TASTYLongSignature")
+  def TASTYLongSignatureAnnot(implicit ctx: Context) = TASTYLongSignatureAnnotType.symbol.asClass
+  lazy val TailrecAnnotType = ctx.requiredClassRef("scala.annotation.tailrec")
+  def TailrecAnnot(implicit ctx: Context) = TailrecAnnotType.symbol.asClass
+  lazy val ThrowsAnnotType = ctx.requiredClassRef("scala.throws")
+  def ThrowsAnnot(implicit ctx: Context) = ThrowsAnnotType.symbol.asClass
+  lazy val TransientAnnotType                = ctx.requiredClassRef("scala.transient")
+  def TransientAnnot(implicit ctx: Context) = TransientAnnotType.symbol.asClass
+  lazy val UncheckedAnnotType = ctx.requiredClassRef("scala.unchecked")
+  def UncheckedAnnot(implicit ctx: Context) = UncheckedAnnotType.symbol.asClass
+  lazy val UncheckedStableAnnotType = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedStable")
+  def UncheckedStableAnnot(implicit ctx: Context) = UncheckedStableAnnotType.symbol.asClass
+  lazy val UncheckedVarianceAnnotType = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedVariance")
+  def UncheckedVarianceAnnot(implicit ctx: Context) = UncheckedVarianceAnnotType.symbol.asClass
+  lazy val VolatileAnnotType = ctx.requiredClassRef("scala.volatile")
+  def VolatileAnnot(implicit ctx: Context) = VolatileAnnotType.symbol.asClass
+  lazy val FieldMetaAnnotType = ctx.requiredClassRef("scala.annotation.meta.field")
+  def FieldMetaAnnot(implicit ctx: Context) = FieldMetaAnnotType.symbol.asClass
+  lazy val GetterMetaAnnotType = ctx.requiredClassRef("scala.annotation.meta.getter")
+  def GetterMetaAnnot(implicit ctx: Context) = GetterMetaAnnotType.symbol.asClass
+  lazy val SetterMetaAnnotType = ctx.requiredClassRef("scala.annotation.meta.setter")
+  def SetterMetaAnnot(implicit ctx: Context) = SetterMetaAnnotType.symbol.asClass
 
   // convenient one-parameter method types
   def methOfAny(tp: Type) = MethodType(List(AnyType), tp)
@@ -370,29 +487,9 @@ class Definitions {
   def methOfAnyRef(tp: Type) = MethodType(List(ObjectType), tp)
 
   // Derived types
-  def AnyType: Type = AnyClass.typeRef
-  def AnyValType: Type = AnyValClass.typeRef
-  def ObjectType: Type = ObjectClass.typeRef
-  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 StringType: Type = StringClass.typeRef
+
   def RepeatedParamType = RepeatedParamClass.typeRef
   def ThrowableType = ThrowableClass.typeRef
-  def OptionType = OptionClass.typeRef
-  def VolatileAnnotType = VolatileAnnot.typeRef
 
   def ClassType(arg: Type)(implicit ctx: Context) = {
     val ctype = ClassClass.typeRef
@@ -407,40 +504,52 @@ class Definitions {
     //  - .linkedClass: the ClassSymbol of the enumeration (class E)
     sym.owner.linkedClass.typeRef
 
-  object FunctionType {
+  object FunctionOf {
     def apply(args: List[Type], resultType: Type)(implicit ctx: Context) =
-      FunctionClass(args.length).typeRef.appliedTo(args ::: resultType :: Nil)
+      FunctionType(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 &&
+          (FunctionType(numArgs).symbol == tsym)) Some(targs.init, targs.last)
       else None
     }
   }
 
-  object ArrayType {
+  object ArrayOf {
     def apply(elem: Type)(implicit ctx: Context) =
       if (ctx.erasedTypes) JavaArrayType(elem)
-      else ArrayClass.typeRef.appliedTo(elem :: Nil)
+      else ArrayType.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 ArrayType.symbol) && at.argInfos.length == 1 => Some(at.argInfos.head)
       case _ => None
     }
   }
 
-  object MultiArrayType {
+  /** An extractor for multi-dimensional arrays.
+   *  Note that this will also extract the high bound if an
+   *  element type is a wildcard. E.g.
+   *
+   *     Array[_ <: Array[_ <: Number]]
+   *
+   *  would match
+   *
+   *     MultiArrayOf(<Number>, 2)
+   */
+  object MultiArrayOf {
     def apply(elem: Type, ndims: Int)(implicit ctx: Context): Type =
-      if (ndims == 0) elem else ArrayType(apply(elem, ndims - 1))
+      if (ndims == 0) elem else ArrayOf(apply(elem, ndims - 1))
     def unapply(tp: Type)(implicit ctx: Context): Option[(Type, Int)] = tp match {
-      case ArrayType(elemtp) =>
-        elemtp match {
-          case MultiArrayType(finalElemTp, n) => Some(finalElemTp, n + 1)
+      case ArrayOf(elemtp) =>
+        def recur(elemtp: Type): Option[(Type, Int)] = elemtp.dealias match {
+          case TypeBounds(lo, hi) => recur(hi)
+          case MultiArrayOf(finalElemTp, n) => Some(finalElemTp, n + 1)
           case _ => Some(elemtp, 1)
         }
+        recur(elemtp)
       case _ =>
         None
     }
@@ -448,43 +557,71 @@ 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 AbstractFunctionType = mkArityArray("scala.runtime.AbstractFunction", MaxFunctionArity, 0)
+  val AbstractFunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => AbstractFunctionType.map(_.symbol.asClass))
+  def AbstractFunctionClass(n: Int)(implicit ctx: Context) = AbstractFunctionClassPerRun()(ctx)(n)
+  lazy val FunctionType = mkArityArray("scala.Function", MaxFunctionArity, 0)
+  def FunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => FunctionType.map(_.symbol.asClass))
+  def FunctionClass(n: Int)(implicit ctx: Context) = FunctionClassPerRun()(ctx)(n)
+    lazy val Function0_applyR = FunctionType(0).symbol.requiredMethodRef(nme.apply)
+    def Function0_apply(implicit ctx: Context) = Function0_applyR.symbol
 
-  lazy val TupleClass = mkArityArray("scala.Tuple", MaxTupleArity, 2)
-  lazy val ProductNClass = mkArityArray("scala.Product", MaxTupleArity, 0)
+  lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 2)
+  lazy val ProductNType = 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
+  private lazy val FunctionTypes: Set[TypeRef] = FunctionType.toSet
+  private lazy val TupleTypes: Set[TypeRef] = TupleType.toSet
+  private lazy val ProductTypes: Set[TypeRef] = ProductNType.toSet
 
-  /** `Modules whose members are in the default namespace and their module classes */
-  lazy val UnqualifiedOwners = RootImports.toSet ++ RootImports.map(_.moduleClass)
+  /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
+  def scalaClassName(cls: Symbol)(implicit ctx: Context): TypeName =
+    if (cls.isClass && cls.owner == ScalaPackageClass) cls.asClass.name else EmptyTypeName
 
-  lazy val PhantomClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass)
+  /** If type `ref` refers to a class in the scala package, its name, otherwise EmptyTypeName */
+  def scalaClassName(ref: Type)(implicit ctx: Context): TypeName = scalaClassName(ref.classSymbol)
+
+  private def isVarArityClass(cls: Symbol, prefix: Name) = {
+    val name = scalaClassName(cls)
+    name.startsWith(prefix) && name.drop(prefix.length).forall(_.isDigit)
+  }
 
-  lazy val isPolymorphicAfterErasure = Set[Symbol](Any_isInstanceOf, Any_asInstanceOf, newRefArrayMethod)
+  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[() => Symbol](() => JavaLangPackageVal, () => ScalaPackageVal, () => ScalaPredefModule, () => DottyPredefModule)
+  val RootImportFns = List[() => TermRef](
+      () => JavaLangPackageVal.termRef,
+      () => ScalaPackageVal.termRef,
+      () => ScalaPredefModuleRef,
+      () => DottyPredefModuleRef)
 
-  lazy val RootImports = RootImportFns.map(_())
+  lazy val RootImportTypes = RootImportFns.map(_())
+
+  /** `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)
+
+  def isPolymorphicAfterErasure(sym: Symbol) =
+     (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf) || (sym eq newRefArrayMethod)
 
   def isTupleType(tp: Type)(implicit ctx: Context) = {
     val arity = tp.dealias.argInfos.length
-    arity <= MaxTupleArity && (tp isRef TupleClass(arity))
+    arity <= MaxTupleArity && TupleType(arity) != null && (tp isRef TupleType(arity).symbol)
   }
 
   def tupleType(elems: List[Type]) = {
-    TupleClass(elems.size).typeRef.appliedTo(elems)
+    TupleType(elems.size).appliedTo(elems)
   }
 
   def isProductSubType(tp: Type)(implicit ctx: Context) =
-    (tp derivesFrom ProductClass) && tp.baseClasses.exists(ProductClasses contains _)
+    (tp derivesFrom ProductType.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 FunctionType(arity).symbol)
   }
 
   def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
@@ -556,54 +693,49 @@ 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
-    vcls
+  /** This class would also be obviated by the implicit function type design */
+  class PerRun[T](generate: Context => T) {
+    private var current: RunId = NoRunId
+    private var cached: T = _
+    def apply()(implicit ctx: Context): T = {
+      if (current != ctx.runId) {
+        cached = generate(ctx)
+        current = ctx.runId
+      }
+      cached
+    }
   }
 
-  /** The classes for which a Ref type exists. */
-  lazy val refClassKeys: collection.Set[Symbol] = ScalaNumericValueClasses + BooleanClass + ObjectClass
+  lazy val ScalaNumericValueTypeList = List(
+    ByteType, ShortType, CharType, IntType, LongType, FloatType, DoubleType)
+
+  private lazy val ScalaNumericValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypeList.toSet
+  private lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes + UnitType + BooleanType
+  private lazy val ScalaBoxedTypes = ScalaValueTypes map (t => boxedTypes(t.name))
 
-  lazy val refClass: Map[Symbol, Symbol] =
-    refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.${rc.name}Ref")).toMap
+  val ScalaNumericValueClasses = new PerRun[collection.Set[Symbol]](implicit ctx => ScalaNumericValueTypes.map(_.symbol))
+  val ScalaValueClasses        = new PerRun[collection.Set[Symbol]](implicit ctx => ScalaValueTypes.map(_.symbol))
+  val ScalaBoxedClasses        = new PerRun[collection.Set[Symbol]](implicit ctx => ScalaBoxedTypes.map(_.symbol))
 
-  lazy val volatileRefClass: Map[Symbol, Symbol] =
-    refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.Volatile${rc.name}Ref")).toMap
+  private val boxedTypes = mutable.Map[TypeName, TypeRef]()
+  private val valueTypeEnc = mutable.Map[TypeName, PrimitiveClassEnc]()
 
-  lazy val boxedRefClasses: collection.Set[Symbol] =
-    refClassKeys.flatMap(k => Set(refClass(k), volatileRefClass(k)))
+//  private val unboxedTypeRef = mutable.Map[TypeName, TypeRef]()
+//  private val javaTypeToValueTypeRef = mutable.Map[Class[_], TypeRef]()
+//  private val valueTypeNameToJavaType = mutable.Map[TypeName, Class[_]]()
+
+  private def valueTypeRef(name: String, boxed: TypeRef, jtype: Class[_], enc: Int): TypeRef = {
+    val vcls = ctx.requiredClassRef(name)
+    boxedTypes(vcls.name) = boxed
+    valueTypeEnc(vcls.name) = enc
+//    unboxedTypeRef(boxed.name) = vcls
+//    javaTypeToValueTypeRef(jtype) = vcls
+//    valueTypeNameToJavaType(vcls.name) = jtype
+    vcls
+  }
+
+  /** The type of the boxed class corresponding to primitive value type `tp`. */
+  def boxedType(tp: Type)(implicit ctx: Context): TypeRef = boxedTypes(scalaClassName(tp))
 
   def wrapArrayMethodName(elemtp: Type): TermName = {
     val cls = elemtp.classSymbol
@@ -612,6 +744,8 @@ class Definitions {
     else nme.genericWrapArray
   }
 
+  type PrimitiveClassEnc = Int
+
   val ByteEnc = 2
   val ShortEnc = ByteEnc * 3
   val CharEnc = 5
@@ -622,8 +756,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) =
+    valueTypeEnc(tref2.name) % valueTypeEnc(tref1.name) == 0
+  def isValueSubClass(sym1: Symbol, sym2: Symbol) =
+    valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
 
   // ----- Initialization ---------------------------------------------------
 
@@ -645,13 +781,13 @@ class Definitions {
     lazy val syntheticCoreMethods = AnyMethods ++ ObjectMethods ++ List(String_+)
 
   private[this] var _isInitialized = false
-  def isInitialized = _isInitialized
+  private def isInitialized = _isInitialized
 
   def init(implicit ctx: Context) = {
     this.ctx = ctx
     if (!_isInitialized) {
       // force initialization of every symbol that is synthesized or hijacked by the compiler
-      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses
+      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses()
       _isInitialized = true
     }
   }
diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index 65df55a9da2c..666908fabd0e 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -207,14 +207,20 @@ object Denotations {
 
     def requiredMethod(name: PreName)(implicit ctx: Context): TermSymbol =
       info.member(name.toTermName).requiredSymbol(_ is Method).asTerm
+    def requiredMethodRef(name: PreName)(implicit ctx: Context): TermRef =
+      requiredMethod(name).termRef
 
     def requiredMethod(name: PreName, argTypes: List[Type])(implicit ctx: Context): TermSymbol =
       info.member(name.toTermName).requiredSymbol(x=>
         (x is Method) && x.info.paramTypess == List(argTypes)
       ).asTerm
+    def requiredMethodRef(name: PreName, argTypes: List[Type])(implicit ctx: Context): TermRef =
+      requiredMethod(name, argTypes).termRef
 
     def requiredValue(name: PreName)(implicit ctx: Context): TermSymbol =
       info.member(name.toTermName).requiredSymbol(_.info.isParameterless).asTerm
+    def requiredValueRef(name: PreName)(implicit ctx: Context): TermRef =
+      requiredValue(name).termRef
 
     def requiredClass(name: PreName)(implicit ctx: Context): ClassSymbol =
       info.member(name.toTypeName).requiredSymbol(_.isClass).asClass
diff --git a/src/dotty/tools/dotc/core/Scopes.scala b/src/dotty/tools/dotc/core/Scopes.scala
index ad9ba4201adb..3daa8117e291 100644
--- a/src/dotty/tools/dotc/core/Scopes.scala
+++ b/src/dotty/tools/dotc/core/Scopes.scala
@@ -142,6 +142,8 @@ object Scopes {
     def openForMutations: MutableScope = unsupported("openForMutations")
 
     final def toText(printer: Printer): Text = printer.toText(this)
+
+    def checkConsistent()(implicit ctx: Context) = ()
   }
 
   /** A subclass of Scope that defines methods for entering and
@@ -240,6 +242,7 @@ object Scopes {
       else {
         hashTable = new Array[ScopeEntry](tableSize)
         enterAllInHash(lastEntry)
+        // checkConsistent() // DEBUG
       }
 
     private def enterAllInHash(e: ScopeEntry, n: Int = 0)(implicit ctx: Context): Unit = {
@@ -378,6 +381,17 @@ object Scopes {
     }
 
     override def openForMutations: MutableScope = this
+
+    /** Check that all symbols in this scope are in their correct hashtable buckets. */
+    override def checkConsistent()(implicit ctx: Context) = {
+      var e = lastEntry
+      while (e != null) {
+        var e1 = lookupEntry(e.name)
+        while (e1 != e && e1 != null) e1 = lookupNextEntry(e1)
+        assert(e1 == e, s"PANIC: Entry ${e.name} is badly linked")
+        e = e.prev
+      }
+    }
   }
 
   /** Create a new scope */
diff --git a/src/dotty/tools/dotc/core/StdNames.scala b/src/dotty/tools/dotc/core/StdNames.scala
index 7c73d95da242..e8cddd3d4743 100644
--- a/src/dotty/tools/dotc/core/StdNames.scala
+++ b/src/dotty/tools/dotc/core/StdNames.scala
@@ -176,19 +176,22 @@ object StdNames {
     final val LAMBDA_ARG_PREFIX: N              = "hk$"
     final val LAMBDA_ARG_PREFIXhead: Char       = LAMBDA_ARG_PREFIX.head
 
-    final val Any: N             = "Any"
-    final val AnyVal: N          = "AnyVal"
-    final val ExprApi: N         = "ExprApi"
-    final val Mirror: N          = "Mirror"
-    final val Nothing: N         = "Nothing"
-    final val Null: N            = "Null"
-    final val Object: N          = "Object"
-    final val PartialFunction: N = "PartialFunction"
-    final val PrefixType: N      = "PrefixType"
-    final val Product: N         = "Product"
-    final val Serializable: N    = "Serializable"
-    final val Singleton: N       = "Singleton"
-    final val Throwable: N       = "Throwable"
+    final val AbstractFunction: N    = "AbstractFunction"
+    final val Any: N                 = "Any"
+    final val AnyVal: N              = "AnyVal"
+    final val ExprApi: N             = "ExprApi"
+    final val Function: N            = "Function"
+    final val Mirror: N              = "Mirror"
+    final val Nothing: N             = "Nothing"
+    final val Null: N                = "Null"
+    final val Object: N              = "Object"
+    final val PartialFunction: N     = "PartialFunction"
+    final val PrefixType: N          = "PrefixType"
+    final val Product: N             = "Product"
+    final val Serializable: N        = "Serializable"
+    final val Singleton: N           = "Singleton"
+    final val Throwable: N           = "Throwable"
+    final val Tuple: N               = "Tuple"
 
     final val ClassfileAnnotation: N = "ClassfileAnnotation"
     final val ClassManifest: N       = "ClassManifest"
diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index 20d674b864b5..5d079640fb9a 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -163,6 +163,11 @@ object SymDenotations {
     }
 
     private def completeFrom(completer: LazyType)(implicit ctx: Context): Unit = {
+      if (completions ne noPrinter) {
+        completions.println(i"${"  " * indent}completing ${if (isType) "type" else "val"} $name")
+        indent += 1
+      }
+      indent += 1
       if (myFlags is Touched) throw CyclicReference(this)
       myFlags |= Touched
 
@@ -173,6 +178,11 @@ object SymDenotations {
           completions.println(s"error while completing ${this.debugString}")
           throw ex
       }
+      finally
+        if (completions ne noPrinter) {
+          indent -= 1
+          completions.println(i"${"  " * indent}completed $name in $owner")
+        }
       // completions.println(s"completed ${this.debugString}")
     }
 
@@ -417,10 +427,12 @@ object SymDenotations {
       name.toTermName == nme.EVT2U
 
     /** Is symbol a primitive value class? */
-    def isPrimitiveValueClass(implicit ctx: Context) = defn.ScalaValueClasses contains symbol
+    def isPrimitiveValueClass(implicit ctx: Context) =
+      maybeOwner == defn.ScalaPackageClass && defn.ScalaValueClasses().contains(symbol)
 
     /** Is symbol a primitive numeric value class? */
-    def isNumericValueClass(implicit ctx: Context) = defn.ScalaNumericValueClasses contains symbol
+    def isNumericValueClass(implicit ctx: Context) =
+      maybeOwner == defn.ScalaPackageClass && defn.ScalaNumericValueClasses().contains(symbol)
 
     /** Is symbol a phantom class for which no runtime representation exists? */
     def isPhantomClass(implicit ctx: Context) = defn.PhantomClasses contains symbol
@@ -1870,4 +1882,6 @@ object SymDenotations {
   }
 
   private val AccessorOrLabel = Accessor | Label
+
+  @sharable private var indent = 0 // for completions printing
 }
diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala
index 100f87a54fda..e33f9651ecd7 100644
--- a/src/dotty/tools/dotc/core/Symbols.scala
+++ b/src/dotty/tools/dotc/core/Symbols.scala
@@ -339,9 +339,13 @@ trait Symbols { this: Context =>
   def requiredPackage(path: PreName): TermSymbol =
     base.staticRef(path.toTermName).requiredSymbol(_ is Package).asTerm
 
+  def requiredPackageRef(path: PreName): TermRef = requiredPackage(path).termRef
+
   def requiredClass(path: PreName): ClassSymbol =
     base.staticRef(path.toTypeName).requiredSymbol(_.isClass).asClass
 
+  def requiredClassRef(path: PreName): TypeRef = requiredClass(path).typeRef
+
   /** Get ClassSymbol if class is either defined in current compilation run
    *  or present on classpath.
    *  Returns NoSymbol otherwise. */
@@ -351,8 +355,7 @@ trait Symbols { this: Context =>
   def requiredModule(path: PreName): TermSymbol =
     base.staticRef(path.toTermName).requiredSymbol(_ is Module).asTerm
 
-  def requiredMethod(cls: ClassSymbol, name: PreName): TermSymbol =
-    cls.info.member(name.toTermName).requiredSymbol(_ is Method).asTerm
+  def requiredModuleRef(path: PreName): TermRef = requiredModule(path).termRef
 }
 
 object Symbols {
diff --git a/src/dotty/tools/dotc/core/TypeApplications.scala b/src/dotty/tools/dotc/core/TypeApplications.scala
index 7274c1f703ce..2631e99644f7 100644
--- a/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -444,7 +444,7 @@ class TypeApplications(val self: Type) extends AnyVal {
 
   /** The element type of a sequence or array */
   def elemType(implicit ctx: Context): Type = self match {
-    case defn.ArrayType(elemtp) => elemtp
+    case defn.ArrayOf(elemtp) => elemtp
     case JavaArrayType(elemtp) => elemtp
     case _ => firstBaseArgInfo(defn.SeqClass)
   }
diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala
index 684e9cbfd8a7..2045de3cedd3 100644
--- a/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -808,7 +808,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
 
   /** The greatest lower bound of a list types */
   final def glb(tps: List[Type]): Type =
-    (defn.AnyType /: tps)(glb)
+    ((defn.AnyType: Type) /: tps)(glb)
 
   /** The least upper bound of two types
    *  @note  We do not admit singleton types in or-types as lubs.
@@ -837,7 +837,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
 
   /** The least upper bound of a list of types */
   final def lub(tps: List[Type]): Type =
-    (defn.NothingType /: tps)(lub)
+    ((defn.NothingType: Type) /: tps)(lub)
 
   /** Merge `t1` into `tp2` if t1 is a subtype of some &-summand of tp2.
    */
diff --git a/src/dotty/tools/dotc/core/TypeErasure.scala b/src/dotty/tools/dotc/core/TypeErasure.scala
index 35c24ff5a686..8f116c85f26b 100644
--- a/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -176,7 +176,7 @@ object TypeErasure {
     else if (sym.isConstructor) outer.addParam(sym.owner.asClass, erase(tp)(erasureCtx))
     else erase.eraseInfo(tp, sym)(erasureCtx) match {
       case einfo: MethodType if sym.isGetter && einfo.resultType.isRef(defn.UnitClass) =>
-        MethodType(Nil, defn.BoxedUnitClass.typeRef)
+        MethodType(Nil, defn.BoxedUnitType)
       case einfo =>
         einfo
     }
@@ -360,7 +360,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           else classParents.mapConserve(eraseTypeRef) match {
             case tr :: trs1 =>
               assert(!tr.classSymbol.is(Trait), cls)
-              val tr1 = if (cls is Trait) defn.ObjectClass.typeRef else tr
+              val tr1 = if (cls is Trait) defn.ObjectType else tr
               tr1 :: trs1.filterNot(_ isRef defn.ObjectClass)
             case nil => nil
           }
@@ -375,7 +375,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
   }
 
   private def eraseArray(tp: RefinedType)(implicit ctx: Context) = {
-    val defn.ArrayType(elemtp) = tp
+    val defn.ArrayOf(elemtp) = tp
     def arrayErasure(tpToErase: Type) =
       erasureFn(isJava, semiEraseVCs = false, isConstructor, wildcardOK)(tpToErase)
     if (elemtp derivesFrom defn.NullClass) JavaArrayType(defn.ObjectType)
@@ -456,14 +456,14 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           if (erasedVCRef.exists) return sigName(erasedVCRef)
         }
         normalizeClass(sym.asClass).fullName.asTypeName
-      case defn.ArrayType(elem) =>
+      case defn.ArrayOf(elem) =>
         sigName(this(tp))
       case JavaArrayType(elem) =>
         sigName(elem) ++ "[]"
       case tp: TermRef =>
         sigName(tp.widen)
       case ExprType(rt) =>
-        sigName(defn.FunctionType(Nil, rt))
+        sigName(defn.FunctionOf(Nil, rt))
       case tp: TypeProxy =>
         sigName(tp.underlying)
       case ErrorType | WildcardType =>
diff --git a/src/dotty/tools/dotc/core/TypeOps.scala b/src/dotty/tools/dotc/core/TypeOps.scala
index aa643256c50b..4cfc5290975f 100644
--- a/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/src/dotty/tools/dotc/core/TypeOps.scala
@@ -481,7 +481,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         formals = formals.updated(name, tp1.typeParamNamed(name))
         normalizeToRef(tp1)
       case ErrorType =>
-        defn.AnyClass.typeRef
+        defn.AnyType
       case AnnotatedType(_, tpe) =>
         normalizeToRef(tpe)
       case _ =>
diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index bfff1a448a42..4ccbd4b4c90a 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -607,9 +607,9 @@ object Types {
 
     /** Is this type a primitive value type which can be widened to the primitive value type `that`? */
     def isValueSubType(that: Type)(implicit ctx: Context) = widen match {
-      case self: TypeRef if defn.ScalaValueClasses contains self.symbol =>
+      case self: TypeRef if self.symbol.isPrimitiveValueClass =>
         that.widenExpr match {
-          case that: TypeRef if defn.ScalaValueClasses contains that.symbol =>
+          case that: TypeRef if that.symbol.isPrimitiveValueClass =>
             defn.isValueSubClass(self.symbol, that.symbol)
           case _ =>
             false
@@ -746,7 +746,8 @@ object Types {
      */
     final def dealias(implicit ctx: Context): Type = this match {
       case tp: TypeRef =>
-        tp.info match {
+        if (tp.symbol.isClass) tp
+        else tp.info match {
           case TypeAlias(tp) => tp.dealias
           case _ => tp
         }
@@ -964,7 +965,7 @@ object Types {
     /** The first parent of this type, AnyRef if list of parents is empty */
     def firstParent(implicit ctx: Context): TypeRef = parents match {
       case p :: _ => p
-      case _ => defn.AnyClass.typeRef
+      case _ => defn.AnyType
     }
 
     /** the self type of the underlying classtype */
@@ -1101,7 +1102,7 @@ object Types {
     def toFunctionType(dropLast: Int = 0)(implicit ctx: Context): Type = this match {
       case mt @ MethodType(_, formals) if !mt.isDependent || ctx.mode.is(Mode.AllowDependentFunctions) =>
         val formals1 = if (dropLast == 0) formals else formals dropRight dropLast
-        defn.FunctionType(
+        defn.FunctionOf(
             formals1 mapConserve (_.underlyingIfRepeated(mt.isJava)), mt.resultType)
     }
 
@@ -1387,7 +1388,7 @@ object Types {
         (lastSymbol.infoOrCompleter == ErrorType ||
         sym.owner.derivesFrom(lastSymbol.owner) && sym.owner != lastSymbol.owner
       ),
-        s"data race? overwriting symbol of ${this.show} / $this / ${this.getClass} / ${lastSymbol.id} / ${sym.id} / ${sym.owner} / ${lastSymbol.owner} / ${ctx.phase}")
+        s"data race? overwriting symbol of ${this.show} / $this / ${this.getClass} / ${lastSymbol.id} / ${sym.id} / ${sym.owner} / ${lastSymbol.owner} / ${ctx.phase} at run ${ctx.runId}")
 
     protected def sig: Signature = Signature.NotAMethod
 
@@ -3258,7 +3259,7 @@ object Types {
       val ex = new CyclicReference(denot)
       if (!(ctx.mode is typer.Mode.CheckCyclic)) {
         cyclicErrors.println(ex.getMessage)
-        for (elem <- ex.getStackTrace take 50)
+        for (elem <- ex.getStackTrace take 200)
           cyclicErrors.println(elem.toString)
       }
       ex
diff --git a/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index b948efebbbf3..9ea24324bc0d 100644
--- a/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -104,7 +104,7 @@ class ClassfileParser(
     /** Parse parents for Java classes. For Scala, return AnyRef, since the real type will be unpickled.
      *  Updates the read pointer of 'in'. */
     def parseParents: List[Type] = {
-      val superType = if (isAnnotation) { in.nextChar; defn.AnnotationClass.typeRef }
+      val superType = if (isAnnotation) { in.nextChar; defn.AnnotationType }
                       else pool.getSuperClass(in.nextChar).typeRef
       val ifaceCount = in.nextChar
       var ifaces = for (i <- (0 until ifaceCount).toList) yield pool.getSuperClass(in.nextChar).typeRef
@@ -115,7 +115,7 @@ class ClassfileParser(
         // is found. If we treat constant subtyping specially, we might be able
         // to do something there. But in any case, the until should be more efficient.
 
-      if (isAnnotation) ifaces = defn.ClassfileAnnotationClass.typeRef :: ifaces
+      if (isAnnotation) ifaces = defn.ClassfileAnnotationType :: ifaces
       superType :: ifaces
     }
 
@@ -324,7 +324,7 @@ class ClassfileParser(
           if (elemtp.typeSymbol.isAbstractType && !(elemtp.derivesFrom(defn.ObjectClass))) {
             elemtp = AndType(elemtp, defn.ObjectType)
           }
-          defn.ArrayType(elemtp)
+          defn.ArrayOf(elemtp)
         case '(' =>
           // we need a method symbol. given in line 486 by calling getType(methodSym, ..)
           val paramtypes = new ListBuffer[Type]()
@@ -614,7 +614,7 @@ class ClassfileParser(
         addConstr(paramTypes)
         if (paramTypes.nonEmpty)
           paramTypes.last match {
-            case defn.ArrayType(elemtp) =>
+            case defn.ArrayOf(elemtp) =>
               addConstr(paramTypes.init :+ defn.RepeatedParamType.appliedTo(elemtp))
             case _ =>
         }
diff --git a/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index 9269109ad64e..709270994b58 100644
--- a/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -99,17 +99,21 @@ object Scala2Unpickler {
       case TempPolyType(tps, cinfo) => (tps, cinfo)
       case cinfo => (Nil, cinfo)
     }
+    val ost =
+      if ((selfInfo eq NoType) && (denot is ModuleClass))
+        denot.owner.thisType select denot.sourceModule
+      else selfInfo
+
+    denot.info = ClassInfo(denot.owner.thisType, denot.classSymbol, Nil, decls, ost) // first rough info to avoid CyclicReferences
     var parentRefs = ctx.normalizeToClassRefs(parents, cls, decls)
-    if (parentRefs.isEmpty) parentRefs = defn.ObjectClass.typeRef :: Nil
+    if (parentRefs.isEmpty) parentRefs = defn.ObjectType :: Nil
     for (tparam <- tparams) {
       val tsym = decls.lookup(tparam.name)
       if (tsym.exists) tsym.setFlag(TypeParam)
       else denot.enter(tparam, decls)
     }
-    val ost =
-      if ((selfInfo eq NoType) && (denot is ModuleClass))
-        denot.owner.thisType select denot.sourceModule
-      else selfInfo
+    denot.info = ClassInfo(
+      denot.owner.thisType, denot.classSymbol, parentRefs, decls, ost) // more refined infowith parents
     if (!(denot.flagsUNSAFE is JavaModule)) ensureConstructor(denot.symbol.asClass, decls)
 
     val scalacCompanion = denot.classSymbol.scalacLinkedClass
@@ -140,7 +144,7 @@ object Scala2Unpickler {
         decls1
       }
 
-    denot.info = ClassInfo(
+    denot.info = ClassInfo( // final info
       denot.owner.thisType, denot.classSymbol, parentRefs, declsInRightOrder, ost)
   }
 }
@@ -379,6 +383,9 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           if (sym.exists || owner.ne(defn.ObjectClass)) sym else declIn(defn.AnyClass)
       }
 
+      def slowSearch(name: Name): Symbol =
+        owner.info.decls.find(_.name == name).getOrElse(NoSymbol)
+
       def nestedObjectSymbol: Symbol = {
         // If the owner is overloaded (i.e. a method), it's not possible to select the
         // right member, so return NoSymbol. This can only happen when unpickling a tree.
@@ -410,13 +417,16 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         fromName(name.toTermName.expandedName(owner)) orElse {
           // (3) Try as a nested object symbol.
           nestedObjectSymbol orElse {
-            //              // (4) Call the mirror's "missing" hook.
+            // (4) Call the mirror's "missing" hook.
             adjust(ctx.base.missingHook(owner, name)) orElse {
               // println(owner.info.decls.toList.map(_.debugString).mkString("\n  ")) // !!! DEBUG
               //              }
               // (5) Create a stub symbol to defer hard failure a little longer.
-              println(i"***** missing reference, looking for $name in $owner")
-              println(i"decls = ${owner.info.decls}")
+              System.err.println(i"***** missing reference, looking for $name in $owner")
+              System.err.println(i"decls = ${owner.info.decls}")
+              owner.info.decls.checkConsistent()
+              if (slowSearch(name).exists)
+                System.err.println(i"**** slow search found: ${slowSearch(name)}")
               new Exception().printStackTrace()
               ctx.newStubSymbol(owner, name, source)
             }
@@ -852,7 +862,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     val end = readNat() + readIndex
     // array elements are trees representing instances of scala.annotation.Annotation
     SeqLiteral(
-      defn.SeqType.appliedTo(defn.AnnotationClass.typeRef :: Nil),
+      defn.SeqType.appliedTo(defn.AnnotationType :: Nil),
       until(end, () => readClassfileAnnotArg(readNat())))
   }
 
diff --git a/src/dotty/tools/dotc/parsing/JavaParsers.scala b/src/dotty/tools/dotc/parsing/JavaParsers.scala
index 52bcdb965067..be7822cdc961 100644
--- a/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -92,12 +92,10 @@ object JavaParsers {
 
     // --------- tree building -----------------------------
 
-    def rootId(name: Name)             = Select(Ident(nme.ROOTPKG), name)
-    def scalaDot(name: Name)           = Select(Ident(nme.scala_), name)
     def scalaAnnotationDot(name: Name) = Select(scalaDot(nme.annotation), name)
 
     def javaDot(name: Name): Tree =
-      Select(rootId(nme.java), name)
+      Select(rootDot(nme.java), name)
 
     def javaLangDot(name: Name): Tree =
       Select(javaDot(nme.lang), name)
diff --git a/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala b/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala
index 46d2a450e2cf..20b655a197be 100644
--- a/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala
+++ b/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala
@@ -70,7 +70,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(implicit ctx: Cont
   private def const(x: Any) = Literal(Constant(x))
   private def wild                          = Ident(nme.WILDCARD)
   private def wildStar                      = Ident(tpnme.WILDCARD_STAR)
-  private def _scala(name: Name)            = Select(Select(Ident(nme.ROOTPKG), nme.scala_), name)
+  private def _scala(name: Name)            = scalaDot(name)
   private def _scala_xml(name: Name)        = Select(_scala(_xml), name)
 
   private def _scala_xml_Comment            = _scala_xml(_Comment)
diff --git a/src/dotty/tools/dotc/printing/PlainPrinter.scala b/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 5daef9fb8657..8b2d68570642 100644
--- a/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -245,10 +245,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
     }
   }
 
-  protected def isOmittablePrefix(sym: Symbol) =
-    (defn.UnqualifiedOwners contains sym) || isEmptyPrefix(sym)
+  protected def isOmittablePrefix(sym: Symbol): Boolean =
+    defn.UnqualifiedOwnerTypes.exists(_.symbol == sym) || isEmptyPrefix(sym)
 
-  protected def isEmptyPrefix(sym: Symbol) =
+  protected def isEmptyPrefix(sym: Symbol): Boolean =
     sym.isEffectiveRoot || sym.isAnonymousClass || sym.name.isReplWrapperName
 
   /** String representation of a definition's type following its name,
diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index d50b551fa3b1..7065976dc4c8 100644
--- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -115,8 +115,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           val cls = tycon.typeSymbol
           if (cls.typeParams.length == args.length) {
             if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*"
-            if (defn.FunctionClasses contains cls) return toTextFunction(args)
-            if (defn.TupleClasses contains cls) return toTextTuple(args)
+            if (defn.isFunctionClass(cls)) return toTextFunction(args)
+            if (defn.isTupleClass(cls)) return toTextTuple(args)
           }
           return (toTextLocal(tycon) ~ "[" ~ Text(args map argText, ", ") ~ "]").close
         }
diff --git a/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala b/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
index 779f0d647a75..9c01aaa9aabf 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 0f1a60282f8a..cd05589c3d3b 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 4d6bf2dc9703..51a68f9033e5 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 9d8abae93035..8fd25f78517a 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 2d0ecaf99660..b65a46249d04 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 9563a7ed0645..98abbb26d144 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 a414c639958a..1b9b898f2140 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 087e15c71685..90e105ee7f17 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 aecc1b86f96b..3b629f9b6690 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 4d8c8ae40fff..9d182382d211 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 ff354a54c6d1..ffb4ae756105 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 1f18a7318d24..7680e283e530 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 2df7a9825189..5b4d4268367b 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 fa931a3794b1..a496f80ceef0 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 441d3ef2b2e3..ddcdb8e4f6bc 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 1f47b4486377..0ee709539096 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 b2d45b661e9b..c57d6fd1a632 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)
diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 87bed88954ee..64047cc1ee71 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -949,7 +949,7 @@ trait Applications extends Compatibility { self: Typer =>
     /** The shape of given tree as a type; cannot handle named arguments. */
     def typeShape(tree: untpd.Tree): Type = tree match {
       case untpd.Function(args, body) =>
-        defn.FunctionType(args map Function.const(defn.AnyType), typeShape(body))
+        defn.FunctionOf(args map Function.const(defn.AnyType), typeShape(body))
       case _ =>
         defn.NothingType
     }
@@ -1068,7 +1068,7 @@ trait Applications extends Compatibility { self: Typer =>
         val alts1 = alts filter pt.isMatchedBy
         resolveOverloaded(alts1, pt1, targs)
 
-      case defn.FunctionType(args, resultType) =>
+      case defn.FunctionOf(args, resultType) =>
         narrowByTypes(alts, args, resultType)
 
       case pt =>
@@ -1102,8 +1102,8 @@ trait Applications extends Compatibility { self: Typer =>
     }
     val clss = numericClasses(ts, Set())
     if (clss.size > 1) {
-      val lub = defn.ScalaNumericValueClassList.find(lubCls =>
-        clss.forall(defn.isValueSubClass(_, lubCls))).get.typeRef
+      val lub = defn.ScalaNumericValueTypeList.find(lubTpe =>
+        clss.forall(cls => defn.isValueSubType(cls.typeRef, lubTpe))).get
       ts.mapConserve(adapt(_, lub))
     }
     else ts
diff --git a/src/dotty/tools/dotc/typer/Checking.scala b/src/dotty/tools/dotc/typer/Checking.scala
index 3dc7b67dfe97..9dfe462329ee 100644
--- a/src/dotty/tools/dotc/typer/Checking.scala
+++ b/src/dotty/tools/dotc/typer/Checking.scala
@@ -310,7 +310,7 @@ trait Checking {
  /**  Check that `tp` is a class type with a stable prefix. Also, if `traitReq` is
    *  true check that `tp` is a trait.
    *  Stability checking is disabled in phases after RefChecks.
-   *  @return  `tp` itself if it is a class or trait ref, ObjectClass.typeRef if not.
+   *  @return  `tp` itself if it is a class or trait ref, ObjectType if not.
    */
   def checkClassTypeWithStablePrefix(tp: Type, pos: Position, traitReq: Boolean)(implicit ctx: Context): Type =
     tp.underlyingClassRef(refinementOK = false) match {
@@ -320,7 +320,7 @@ trait Checking {
         tp
       case _ =>
         ctx.error(d"$tp is not a class type", pos)
-        defn.ObjectClass.typeRef
+        defn.ObjectType
   }
 
   /** Check that a non-implicit parameter making up the first parameter section of an
diff --git a/src/dotty/tools/dotc/typer/FrontEnd.scala b/src/dotty/tools/dotc/typer/FrontEnd.scala
index e8a0adf1998e..eee8744a5dd4 100644
--- a/src/dotty/tools/dotc/typer/FrontEnd.scala
+++ b/src/dotty/tools/dotc/typer/FrontEnd.scala
@@ -4,17 +4,20 @@ package typer
 import core._
 import Phases._
 import Contexts._
+import Symbols._
 import dotty.tools.dotc.parsing.JavaParsers.JavaParser
 import parsing.Parsers.Parser
 import config.Printers._
 import util.Stats._
 import scala.util.control.NonFatal
+import ast.Trees._
 import util.FreshNameCreator
 
 class FrontEnd extends Phase {
 
   override def phaseName = "frontend"
   override def isTyper = true
+  import ast.tpd
 
   def monitor(doing: String)(body: => Unit)(implicit ctx: Context) =
     try body
@@ -47,6 +50,16 @@ class FrontEnd extends Phase {
     record("retainedTypedTrees", unit.tpdTree.treeSize)
   }
 
+  private def firstTopLevelDef(trees: List[tpd.Tree])(implicit ctx: Context): Symbol = trees match {
+    case PackageDef(_, defs) :: _    => firstTopLevelDef(defs)
+    case Import(_, _) :: defs        => firstTopLevelDef(defs)
+    case (tree @ TypeDef(_, _)) :: _ => tree.symbol
+    case _ => NoSymbol
+  }
+
+  private def discardAfterTyper(unit: CompilationUnit)(implicit ctx: Context) =
+    unit.isJava || firstTopLevelDef(unit.tpdTree :: Nil).isPrimitiveValueClass
+
   override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
     val unitContexts = for (unit <- units) yield
       ctx.fresh.setCompilationUnit(unit).setFreshNames(new FreshNameCreator.Default)
@@ -55,7 +68,7 @@ class FrontEnd extends Phase {
     unitContexts foreach (enterSyms(_))
     unitContexts foreach (typeCheck(_))
     record("totalTrees", ast.Trees.ntrees)
-    unitContexts.map(_.compilationUnit).filter(!_.isJava)
+    unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)
   }
 
   override def run(implicit ctx: Context): Unit = {
diff --git a/src/dotty/tools/dotc/typer/ImportInfo.scala b/src/dotty/tools/dotc/typer/ImportInfo.scala
index fe999b56126a..2ca90311feba 100644
--- a/src/dotty/tools/dotc/typer/ImportInfo.scala
+++ b/src/dotty/tools/dotc/typer/ImportInfo.scala
@@ -11,9 +11,9 @@ import Decorators.StringInterpolators
 
 object ImportInfo {
   /** The import info for a root import from given symbol `sym` */
-  def rootImport(sym: () => Symbol)(implicit ctx: Context) = {
+  def rootImport(refFn: () => TermRef)(implicit ctx: Context) = {
     val selectors = untpd.Ident(nme.WILDCARD) :: Nil
-    def expr = tpd.Ident(sym().valRef)
+    def expr = tpd.Ident(refFn())
     def imp = tpd.Import(expr, selectors)
     new ImportInfo(imp.symbol, selectors, isRootImport = true)
   }
@@ -101,7 +101,7 @@ class ImportInfo(symf: => Symbol, val selectors: List[untpd.Tree], val isRootImp
       case Pair(_, Ident(nme.WILDCARD)) => true
       case _ => false
     }
-    if ((defn.RootImports contains sym) && hasMaskingSelector) sym else NoSymbol
+    if ((defn.RootImportTypes exists (_.symbol == sym)) && hasMaskingSelector) sym else NoSymbol
   }
 
   override def toString = {
diff --git a/src/dotty/tools/dotc/typer/Namer.scala b/src/dotty/tools/dotc/typer/Namer.scala
index 3c491fa7a085..999efff090ed 100644
--- a/src/dotty/tools/dotc/typer/Namer.scala
+++ b/src/dotty/tools/dotc/typer/Namer.scala
@@ -579,7 +579,7 @@ class Namer { typer: Typer =>
           val pt = checkClassTypeWithStablePrefix(ptype, parent.pos, traitReq = parent ne parents.head)
           if (pt.derivesFrom(cls)) {
             ctx.error(i"cyclic inheritance: $cls extends itself", parent.pos)
-            defn.ObjectClass.typeRef
+            defn.ObjectType
           }
           else pt
         }
diff --git a/src/dotty/tools/dotc/typer/ProtoTypes.scala b/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 2b19d9db3712..db196f0c2fbe 100644
--- a/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -370,7 +370,7 @@ object ProtoTypes {
             if (pt.isInstanceOf[ApplyingProto])
               mt.derivedMethodType(mt.paramNames, mt.paramTypes, rt)
             else {
-              val ft = defn.FunctionType(mt.paramTypes, rt)
+              val ft = defn.FunctionOf(mt.paramTypes, rt)
               if (mt.paramTypes.nonEmpty || ft <:< pt) ft else rt
             }
           }
diff --git a/src/dotty/tools/dotc/typer/ReTyper.scala b/src/dotty/tools/dotc/typer/ReTyper.scala
index f4e4f52b916d..49718fd008d6 100644
--- a/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -10,6 +10,7 @@ import typer.ProtoTypes._
 import ast.{tpd, untpd}
 import ast.Trees._
 import scala.util.control.NonFatal
+import config.Printers
 
 /** A version of Typer that keeps all symbols defined and referenced in a
  *  previously typed tree.
@@ -91,7 +92,7 @@ class ReTyper extends Typer {
     try super.typedUnadapted(tree, pt)
     catch {
       case NonFatal(ex) =>
-        println(i"exception while typing $tree of class ${tree.getClass} # ${tree.uniqueId}")
+        Printers.transforms.println(i"exception while typing $tree of class ${tree.getClass} # ${tree.uniqueId}")
         throw ex
     }
 
diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 25030012c4d9..af5fdd428b23 100644
--- a/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -350,7 +350,7 @@ trait TypeAssigner {
 
   def assignType(tree: untpd.SeqLiteral, elems: List[Tree])(implicit ctx: Context) = tree match {
     case tree: JavaSeqLiteral =>
-      tree.withType(defn.ArrayType(ctx.typeComparer.lub(elems.tpes).widen))
+      tree.withType(defn.ArrayOf(ctx.typeComparer.lub(elems.tpes).widen))
     case _ =>
       val ownType =
         if (ctx.erasedTypes) defn.SeqType
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index c621d96c4a6d..10bca44bfb27 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -373,7 +373,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     def regularTyped(isWildcard: Boolean) = {
       val tpt1 =
         if (untpd.isWildcardStarArg(tree))
-          TypeTree(defn.SeqClass.typeRef.appliedTo(pt :: Nil))
+          TypeTree(defn.SeqType.appliedTo(pt :: Nil))
         else
           checkSimpleKinded(typedType(tree.tpt))
       val expr1 =
@@ -891,7 +891,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedAnnotation(annot: untpd.Tree)(implicit ctx: Context): Tree = track("typedAnnotation") {
-    typed(annot, defn.AnnotationClass.typeRef)
+    typed(annot, defn.AnnotationType)
   }
 
   def typedValDef(vdef: untpd.ValDef, sym: Symbol)(implicit ctx: Context) = track("typedValDef") {
@@ -1034,7 +1034,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedAnnotated(tree: untpd.Annotated, pt: Type)(implicit ctx: Context): Tree = track("typedAnnotated") {
-    val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)
+    val annot1 = typedExpr(tree.annot, defn.AnnotationType)
     val arg1 = typed(tree.arg, pt)
     if (ctx.mode is Mode.Type)
       assignType(cpy.Annotated(tree)(annot1, arg1), annot1, arg1)
diff --git a/src/dotty/tools/io/ClassPath.scala b/src/dotty/tools/io/ClassPath.scala
index 0d1402430e25..e30eca492410 100644
--- a/src/dotty/tools/io/ClassPath.scala
+++ b/src/dotty/tools/io/ClassPath.scala
@@ -25,13 +25,16 @@ import language.postfixOps
  *  @author Stepan Koltsov
  */
 object ClassPath {
+
   /** Expand single path entry */
   private def expandS(pattern: String): List[String] = {
     val wildSuffix = File.separator + "*"
 
     /** Get all subdirectories, jars, zips out of a directory. */
-    def lsDir(dir: Directory, filt: String => Boolean = _ => true) =
-      dir.list filter (x => filt(x.name) && (x.isDirectory || isJarOrZip(x))) map (_.path) toList
+    def lsDir(dir: Directory, filt: String => Boolean = _ => true) = {
+      val files = synchronized(dir.list)
+      files filter (x => filt(x.name) && (x.isDirectory || isJarOrZip(x))) map (_.path) toList
+    }
 
     def basedir(s: String) =
       if (s contains File.separator) s.substring(0, s.lastIndexOf(File.separator))
diff --git a/test/dotc/scala-collections.whitelist b/test/dotc/scala-collections.whitelist
index 76fa64c8e9b4..59388ac780a0 100644
--- a/test/dotc/scala-collections.whitelist
+++ b/test/dotc/scala-collections.whitelist
@@ -1,47 +1,30 @@
-# no sig for NoType
-#  no sig for ErasedValueType(class RichShort,NoType)
-#  no sig for TypeRef(TermRef(ThisType(TypeRef(NoPrefix,scala)),runtime),RichShort)
-#  failure while taking result signture of (x: Short)runtime.RichShort: runtime.RichShort
-#  cannot take signature of (x: Short)runtime.RichShort
-#  exception occurred while typechecking ./scala-scala/src/library/scala/runtime/RichByte.scala
-#
-#./scala-scala/src/library/scala/runtime/RichBoolean.scala
-#./scala-scala/src/library/scala/runtime/RichByte.scala
-#./scala-scala/src/library/scala/runtime/RichChar.scala
-#./scala-scala/src/library/scala/runtime/RichDouble.scala
-#./scala-scala/src/library/scala/runtime/RichException.scala
-#./scala-scala/src/library/scala/runtime/RichFloat.scala
-#./scala-scala/src/library/scala/runtime/RichInt.scala
-#./scala-scala/src/library/scala/runtime/RichLong.scala
-#./scala-scala/src/library/scala/runtime/RichShort.scala
-
-
-
-#
-# no sig for NoType
-#  no sig for ErasedValueType(class RichShort,NoType)
-#  no sig for TypeRef(TermRef(ThisType(TypeRef(NoPrefix,scala)),runtime),RichShort)
-#  failure while taking result signture of (x: Short)runtime.RichShort: runtime.RichShort
-#  cannot take signature of (x: Short)runtime.RichShort
-#  exception occurred while typechecking ./scala-scala/src/library/scala/Array.scala
-#
-#./scala-scala/src/library/scala/Array.scala
-#./scala-scala/src/library/scala/NotImplementedError.scala
+./scala-scala/src/library/scala/runtime/RichBoolean.scala
+./scala-scala/src/library/scala/runtime/RichByte.scala
+./scala-scala/src/library/scala/runtime/RichChar.scala
+./scala-scala/src/library/scala/runtime/RichDouble.scala
+./scala-scala/src/library/scala/runtime/RichException.scala
+./scala-scala/src/library/scala/runtime/RichFloat.scala
+./scala-scala/src/library/scala/runtime/RichInt.scala
+./scala-scala/src/library/scala/runtime/RichLong.scala
+./scala-scala/src/library/scala/runtime/RichShort.scala
+
+./scala-scala/src/library/scala/Array.scala
+./scala-scala/src/library/scala/NotImplementedError.scala
 
 ./scala-scala/src/library/scala/AnyValCompanion.scala
 
-# Does not pass refchecks:
-#  method getClass of type ()Class[_ <: AnyVal] cannot override final member method getClass in class Any
+# AnyVal is a synthesized class in Dotty, cannot be compiled from source.
 #./scala-scala/src/library/scala/AnyVal.scala
-#./scala-scala/src/library/scala/Boolean.scala
-#./scala-scala/src/library/scala/Byte.scala
-#./scala-scala/src/library/scala/Char.scala
-#./scala-scala/src/library/scala/Double.scala
-#./scala-scala/src/library/scala/Float.scala
-#./scala-scala/src/library/scala/Int.scala
-#./scala-scala/src/library/scala/Long.scala
-#./scala-scala/src/library/scala/Short.scala
-#./scala-scala/src/library/scala/Unit.scala
+
+./scala-scala/src/library/scala/Boolean.scala
+./scala-scala/src/library/scala/Byte.scala
+./scala-scala/src/library/scala/Char.scala
+./scala-scala/src/library/scala/Double.scala
+./scala-scala/src/library/scala/Float.scala
+./scala-scala/src/library/scala/Int.scala
+./scala-scala/src/library/scala/Long.scala
+./scala-scala/src/library/scala/Short.scala
+./scala-scala/src/library/scala/Unit.scala
 
 ./scala-scala/src/library/scala/Cloneable.scala
 ./scala-scala/src/library/scala/DelayedInit.scala
@@ -52,38 +35,34 @@
 ./scala-scala/src/library/scala/Mutable.scala
 ./scala-scala/src/library/scala/NotNull.scala
 
-# https://github.com/lampepfl/dotty/issues/911
 ./scala-scala/src/library/scala/Option.scala
 
 ./scala-scala/src/library/scala/PartialFunction.scala
 ./scala-scala/src/library/scala/Predef.scala
 
-# Causes data races #907
-# java.lang.AssertionError: assertion failed: data race? overwriting symbol of Product1 / TypeRef(ThisType(TypeRef(NoPrefix,scala)),Product1) / class dotty.tools.dotc.core.Types$CachedTypeRef / 190 / 4820 / module class scala / module class scala / frontend, took 2.154 sec
-#./scala-scala/src/library/scala/Product.scala
-#./scala-scala/src/library/scala/Product1.scala
-#./scala-scala/src/library/scala/Product10.scala
-#./scala-scala/src/library/scala/Product11.scala
-#./scala-scala/src/library/scala/Product12.scala
-#./scala-scala/src/library/scala/Product13.scala
-#./scala-scala/src/library/scala/Product14.scala
-#./scala-scala/src/library/scala/Product15.scala
-#./scala-scala/src/library/scala/Product16.scala
-#./scala-scala/src/library/scala/Product17.scala
-#./scala-scala/src/library/scala/Product18.scala
-#./scala-scala/src/library/scala/Product19.scala
-#./scala-scala/src/library/scala/Product2.scala
-#./scala-scala/src/library/scala/Product20.scala
-#./scala-scala/src/library/scala/Product21.scala
-#./scala-scala/src/library/scala/Product22.scala
-#./scala-scala/src/library/scala/Product3.scala
-#./scala-scala/src/library/scala/Product4.scala
-#./scala-scala/src/library/scala/Product5.scala
-#./scala-scala/src/library/scala/Product6.scala
-#./scala-scala/src/library/scala/Product7.scala
-#./scala-scala/src/library/scala/Product8.scala
-#./scala-scala/src/library/scala/Product9.scala
-
+./scala-scala/src/library/scala/Product.scala
+./scala-scala/src/library/scala/Product1.scala
+./scala-scala/src/library/scala/Product10.scala
+./scala-scala/src/library/scala/Product11.scala
+./scala-scala/src/library/scala/Product12.scala
+./scala-scala/src/library/scala/Product13.scala
+./scala-scala/src/library/scala/Product14.scala
+./scala-scala/src/library/scala/Product15.scala
+./scala-scala/src/library/scala/Product16.scala
+./scala-scala/src/library/scala/Product17.scala
+./scala-scala/src/library/scala/Product18.scala
+./scala-scala/src/library/scala/Product19.scala
+./scala-scala/src/library/scala/Product2.scala
+./scala-scala/src/library/scala/Product20.scala
+./scala-scala/src/library/scala/Product21.scala
+./scala-scala/src/library/scala/Product22.scala
+./scala-scala/src/library/scala/Product3.scala
+./scala-scala/src/library/scala/Product4.scala
+./scala-scala/src/library/scala/Product5.scala
+./scala-scala/src/library/scala/Product6.scala
+./scala-scala/src/library/scala/Product7.scala
+./scala-scala/src/library/scala/Product8.scala
+./scala-scala/src/library/scala/Product9.scala
 
 ./scala-scala/src/library/scala/Proxy.scala
 ./scala-scala/src/library/scala/SerialVersionUID.scala
@@ -156,3 +135,9 @@
 ./scala-scala/src/library/scala/transient.scala
 ./scala-scala/src/library/scala/unchecked.scala
 ./scala-scala/src/library/scala/volatile.scala
+
+# cyclic reference
+./scala-scala/src/library/scala/collection/GenSeq.scala
+./scala-scala/src/library/scala/collection/GenSeqLike.scala
+
+
diff --git a/tests/pos/lazyValsSepComp.scala b/tests/pos/lazyValsSepComp.scala
index 337447280875..1a7e3702018e 100644
--- a/tests/pos/lazyValsSepComp.scala
+++ b/tests/pos/lazyValsSepComp.scala
@@ -12,5 +12,5 @@ import dotty.tools.dotc.core.Contexts._
 object Foo {
   val definitions: Definitions = null
   def defn = definitions
-  def go = defn.FunctionClass(0)
+  def go = defn.FunctionType(0)
 }