Making definitions permanent

Need to ensure that specially generated symbols in definitions are valid forever; otherwise they would disappear after first run.

8 files changed, 36 insertions, 27 deletions

diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala
index d285fef5a..582853fdf 100644
--- a/src/dotty/tools/dotc/Compiler.scala
+++ b/src/dotty/tools/dotc/Compiler.scala
@@ -16,6 +16,7 @@ class Compiler {
     defn.JavaLangPackageVal :: defn.ScalaPackageVal :: defn.PredefModule :: Nil
 
   def rootContext(implicit ctx: Context): Context = {
+    ctx.definitions.init()
     ctx.usePhases(phases)
     val start = ctx.fresh
       .withPeriod(Period(ctx.runId + 1, FirstPhaseId))
diff --git a/src/dotty/tools/dotc/Run.scala b/src/dotty/tools/dotc/Run.scala
index 923e5f8b2..50614e07b 100644
--- a/src/dotty/tools/dotc/Run.scala
+++ b/src/dotty/tools/dotc/Run.scala
@@ -8,8 +8,6 @@ import util.{SourceFile, NoSource}
 
 class Run(comp: Compiler)(implicit ctx: Context) {
 
-  defn.init()
-
   var units: List[CompilationUnit] = _
 
   def getSource(fileName: String): SourceFile = {
diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala
index df0173467..ea2682516 100644
--- a/src/dotty/tools/dotc/core/Definitions.scala
+++ b/src/dotty/tools/dotc/core/Definitions.scala
@@ -20,8 +20,17 @@ class Definitions(implicit ctx: Context) {
 
   import ctx.{requiredClass, requiredModule, requiredPackage}
 
+  private def newSymbol[N <: Name](owner: Symbol, name: N, flags: FlagSet, info: Type) =
+    ctx.newSymbol(owner, name, flags | Permanent, info)
+
+  private def newClassSymbol(owner: Symbol, name: TypeName, flags: FlagSet, infoFn: ClassSymbol => Type) =
+    ctx.newClassSymbol(owner, name, flags | Permanent, infoFn).entered
+
+  private def newCompleteClassSymbol(owner: Symbol, name: TypeName, flags: FlagSet, parents: List[TypeRef], decls: Scope = newScope) =
+    ctx.newCompleteClassSymbol(owner, name, flags | Permanent, parents, decls).entered
+
   private def newTypeParam(cls: ClassSymbol, name: TypeName, flags: FlagSet, scope: MutableScope) =
-    scope.enter(ctx.newSymbol(cls, name, flags | TypeParamCreationFlags, TypeBounds.empty))
+    scope.enter(newSymbol(cls, name, flags | TypeParamCreationFlags, TypeBounds.empty))
 
   private def newSyntheticTypeParam(cls: ClassSymbol, scope: MutableScope, suffix: String = "T0") =
     newTypeParam(cls, suffix.toTypeName.expandedName(cls), ExpandedName, scope)
@@ -40,14 +49,14 @@ class Definitions(implicit ctx: Context) {
         denot.info = ClassInfo(ScalaPackageClass.thisType, cls, parentRefs, paramDecls)
       }
     }
-    ctx.newClassSymbol(ScalaPackageClass, name, flags, completer).entered
+    newClassSymbol(ScalaPackageClass, name, flags, completer)
   }
 
   private def newMethod(cls: ClassSymbol, name: TermName, info: Type, flags: FlagSet = EmptyFlags): TermSymbol =
-    ctx.newSymbol(cls, name.encode, flags | Method, info).entered.asTerm
+    newSymbol(cls, name.encode, flags | Method, info).entered.asTerm
 
   private def newAliasType(name: TypeName, tpe: Type, flags: FlagSet = EmptyFlags): TypeSymbol =
-    ctx.newSymbol(ScalaPackageClass, name, flags, tpe).entered.asType
+    newSymbol(ScalaPackageClass, name, flags, TypeAlias(tpe)).entered.asType
 
   private def newPolyMethod(cls: ClassSymbol, name: TermName, typeParamCount: Int,
                     resultTypeFn: PolyType => Type, flags: FlagSet = EmptyFlags) = {
@@ -83,12 +92,7 @@ class Definitions(implicit ctx: Context) {
   lazy val JavaLangPackageVal = requiredPackage("java.lang")
 
   lazy val ObjectClass = requiredClass("java.lang.Object")
-  lazy val AnyRefAlias: TypeSymbol = {
-    val anyRef = ctx.newSymbol(
-      ScalaPackageClass, tpnme.AnyRef, EmptyFlags, TypeAlias(ObjectClass.typeConstructor))
-    ScalaPackageClass.enter(anyRef, ScalaPackageClass.decls)
-    anyRef
-  }
+  lazy val AnyRefAlias: TypeSymbol = newAliasType(tpnme.AnyRef, ObjectType)
 
     lazy val Object_## = newMethod(ObjectClass, nme.HASHHASH, ExprType(IntType), Final)
     lazy val Object_== = newMethod(ObjectClass, nme.EQ, methOfAnyRef(BooleanType), Final)
@@ -110,8 +114,8 @@ class Definitions(implicit ctx: Context) {
     def Object_toString  = objMethod(nme.toString_)
     private def objMethod(name: PreName) = ObjectClass.requiredMethod(name)
 
-  lazy val AnyClass: ClassSymbol = ctx.newCompleteClassSymbol(
-    ScalaPackageClass, tpnme.Any, Abstract, Nil).entered
+  lazy val AnyClass: ClassSymbol = newCompleteClassSymbol(
+    ScalaPackageClass, tpnme.Any, Abstract, Nil)
   lazy val AnyValClass: ClassSymbol = requiredClass("scala.AnyVal")
 
     lazy val Any_==       = newMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
@@ -136,10 +140,10 @@ class Definitions(implicit ctx: Context) {
 
   lazy val NotNullClass = requiredClass("scala.NotNull")
 
-  lazy val NothingClass: ClassSymbol = ctx.newCompleteClassSymbol(
-    ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeConstructor)).entered
-  lazy val NullClass: ClassSymbol = ctx.newCompleteClassSymbol(
-    ScalaPackageClass, tpnme.Null, AbstractFinal, List(AnyRefAlias.typeConstructor)).entered
+  lazy val NothingClass: ClassSymbol = newCompleteClassSymbol(
+    ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeConstructor))
+  lazy val NullClass: ClassSymbol = newCompleteClassSymbol(
+    ScalaPackageClass, tpnme.Null, AbstractFinal, List(AnyRefAlias.typeConstructor))
 
   lazy val PredefModule = requiredModule("scala.Predef")
   lazy val NilModule = requiredModule("scala.collection.immutable.Nil")
@@ -148,9 +152,9 @@ class Definitions(implicit ctx: Context) {
   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.
-    ctx.newCompleteClassSymbol(
+    newCompleteClassSymbol(
       ScalaPackageClass, tpnme.Singleton, Trait | Interface | Final,
-      List(AnyClass.typeConstructor), EmptyScope).entered
+      List(AnyClass.typeConstructor), EmptyScope)
   lazy val SeqClass: ClassSymbol = requiredClass("scala.collection.Seq")
   lazy val ArrayClass: ClassSymbol = requiredClass("scala.Array")
   lazy val uncheckedStableClass: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable")
@@ -358,11 +362,11 @@ class Definitions(implicit ctx: Context) {
       tpnme.higherKindedTraitName(vcs.length) ++ (vcs map varianceSuffix).mkString
 
     def createTrait = {
-      val cls = ctx.newClassSymbol(
+      val cls = newClassSymbol(
         ScalaPackageClass,
         traitName,
         Trait | Interface | Synthetic,
-        completer).entered
+        completer)
       _hkTraits += cls
       cls
     }
diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index 4566cfdb8..bfd150999 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -455,7 +455,7 @@ object Denotations {
       val currentPeriod = ctx.period
       val valid = myValidFor
       def stillValid(denot: SymDenotation): Boolean =
-        if (!denot.exists || (denot.flags is PackageClass)) true
+        if (denot is ValidForever) true
         else if (denot.owner is PackageClass)
           (denot.owner.decls.lookup(denot.name) eq denot.symbol) ||
             (denot is ModuleClass) && stillValid(denot.sourceModule) // !!! DEBUG - we should check why module classes are not entered
diff --git a/src/dotty/tools/dotc/core/Flags.scala b/src/dotty/tools/dotc/core/Flags.scala
index 3a54340d8..229d71568 100644
--- a/src/dotty/tools/dotc/core/Flags.scala
+++ b/src/dotty/tools/dotc/core/Flags.scala
@@ -370,6 +370,9 @@ object Flags {
   /** A method that is known to no default parameters */
   final val NoDefaultParams = termFlag(60, "<no-default-param>")
 
+  /** A denotation that is valid in all run-ids */
+  final val Permanent = commonFlag(61, "<permanent>")
+
 // --------- Combined Flag Sets and Conjunctions ----------------------
 
   /** Flags representing source modifiers */
@@ -384,7 +387,7 @@ object Flags {
   final val FromStartFlags =
     AccessFlags | Module | Package | Deferred | Param | Scala2ExistentialCommon | Touched |
     Static | CovariantCommon | ContravariantCommon | ExpandedName | AccessorOrSealed | Frozen |
-    Erroneous | ImplicitCommon
+    Erroneous | ImplicitCommon | Permanent
 
   assert(FromStartFlags.isTermFlags && FromStartFlags.isTypeFlags)
   // TODO: Should check that FromStartFlags do not change in completion
@@ -450,6 +453,9 @@ object Flags {
   /** Has defined or inherited default parameters */
   final val HasDefaultParams = DefaultParameterized | InheritedDefaultParams
 
+  /** Is valid forever */
+  final val ValidForever = Package | Permanent
+
   /** Is a default parameter in Scala 2*/
   final val DefaultParameter = allOf(Param, DefaultParameterized)
 
diff --git a/src/dotty/tools/dotc/core/Periods.scala b/src/dotty/tools/dotc/core/Periods.scala
index 8a1b65f2c..2a38acd15 100644
--- a/src/dotty/tools/dotc/core/Periods.scala
+++ b/src/dotty/tools/dotc/core/Periods.scala
@@ -128,7 +128,7 @@ object Periods {
 
   final val Nowhere = new Period(0)
 
-  final val InitialPeriod = Period(InitialRunId, FirstPhaseId, FirstPhaseId)
+  final val InitialPeriod = Period(InitialRunId, FirstPhaseId)
 
   /** An ordinal number for compiler runs. First run has number 1. */
   type RunId = Int
diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index 910fec909..91f157e2c 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1016,7 +1016,7 @@ object SymDenotations {
   }
 
   object NoDenotation extends SymDenotation(
-    NoSymbol, NoSymbol, "<none>".toTermName, EmptyFlags, NoType) {
+    NoSymbol, NoSymbol, "<none>".toTermName, Permanent, NoType) {
     override def exists = false
     override def isTerm = false
     override def isType = false
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 43065285c..6a36eaaa5 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -824,7 +824,7 @@ class Typer extends Namer with Applications with Implicits {
     }
   }
 
-  def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = {
+  def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = ctx.traceIndented (i"typing $tree") {
 
     def encodeName(tree: untpd.Tree) = tree match {
       case tree: NameTree => tree.withName(tree.name.encode)