Make Definitions survive recompilation of core definitions.

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
     })
   }

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,29 +130,28 @@ 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")
   lazy val AnnotationRetentionClassAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS")
   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

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 _ =>

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)
   }
 

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$() }

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) =

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 _ =>
                 ???
             }

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)

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 =

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
 }

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

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)
     }