Fix caches of info that depends on inherited classes

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -4,7 +4,6 @@ object Config {
 
   final val cacheMembersNamed = true
   final val cacheAsSeenFrom = true
-  final val useFingerPrints = true // note: it currently seems to be slightly faster not to use them! my junit test: 548s without, 560s with.
   final val cacheMemberNames = true
   final val cacheImplicitScopes = true
 

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -597,26 +597,6 @@ object Contexts {
 
     def nextId = { _nextId += 1; _nextId }
 
-    /** A map from a superclass id to the typeref of the class that has it */
-    private[core] var classOfId = new Array[ClassSymbol](Config.InitialSuperIdsSize)
-
-    /** A map from a the typeref of a class to its superclass id */
-    private[core] val superIdOfClass = new mutable.AnyRefMap[ClassSymbol, Int]
-
-    /** The last allocated superclass id */
-    private[core] var lastSuperId = -1
-
-    /** Allocate and return next free superclass id */
-    private[core] def nextSuperId: Int = {
-      lastSuperId += 1
-      if (lastSuperId >= classOfId.length) {
-        val tmp = new Array[ClassSymbol](classOfId.length * 2)
-        classOfId.copyToArray(tmp)
-        classOfId = tmp
-      }
-      lastSuperId
-    }
-
     // Types state
     /** A table for hash consing unique types */
     private[core] val uniques = new util.HashSet[Type](Config.initialUniquesCapacity) {
@@ -682,9 +662,6 @@ object Contexts {
 
     def reset() = {
       for ((_, set) <- uniqueSets) set.clear()
-      for (i <- 0 until classOfId.length) classOfId(i) = null
-      superIdOfClass.clear()
-      lastSuperId = -1
     }
 
     // Test that access is single threaded

compiler/src/dotty/tools/dotc/core/DenotTransformers.scala

@@ -44,8 +44,10 @@ object DenotTransformers {
         val info1 = transformInfo(ref.info, ref.symbol)
         if (info1 eq ref.info) ref
         else ref match {
-          case ref: SymDenotation => ref.copySymDenotation(info = info1)
-          case _ => ref.derivedSingleDenotation(ref.symbol, info1)
+          case ref: SymDenotation =>
+            ref.copySymDenotation(info = info1).copyCaches(ref, ctx.phase.next)
+          case _ =>
+            ref.derivedSingleDenotation(ref.symbol, info1)
         }
       }
     }

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -805,7 +805,7 @@ object Denotations {
               val transformer = ctx.denotTransformers(nextTransformerId)
               //println(s"transforming $this with $transformer")
               try {
-                next = transformer.transform(cur)(ctx.withPhase(transformer)).syncWithParents
+                next = transformer.transform(cur)(ctx.withPhase(transformer))
               } catch {
                 case ex: CyclicReference =>
                   println(s"error while transforming $this") // DEBUG
@@ -817,7 +817,6 @@ object Denotations {
                 next match {
                   case next: ClassDenotation =>
                     assert(!next.is(Package), s"illegal transformation of package denotation by transformer ${ctx.withPhase(transformer).phase}")
-                    next.resetFlag(Frozen)
                   case _ =>
                 }
                 next.insertAfter(cur)

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -349,9 +349,6 @@ object Flags {
   /** A bridge method. Set by Erasure */
   final val Bridge = termFlag(34, "<bridge>")
 
-  /** All class attributes are fully defined */
-  final val FullyCompleted = typeFlag(34, "<fully-completed>")
-
   /** Symbol is a Java varargs bridge */ // (needed?)
   final val VBridge = termFlag(35, "<vbridge>") // TODO remove
 
@@ -375,9 +372,6 @@ object Flags {
   /** Denotation is in train of being loaded and completed, used to catch cyclic dependencies */
   final val Touched = commonFlag(48, "<touched>")
 
-  /** Class is not allowed to accept new members because fingerprint of subclass has been taken */
-  final val Frozen = commonFlag(49, "<frozen>")
-
   /** An error symbol */
   final val Erroneous = commonFlag(50, "<is-error>")
 
@@ -450,7 +444,7 @@ object Flags {
     Module | Package | Deferred | MethodOrHKCommon | Param | ParamAccessor |
     Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
     CovariantOrOuter | ContravariantOrLabel | CaseAccessorOrBaseTypeArg |
-    Fresh | Frozen | Erroneous | ImplicitCommon | Permanent | Synthetic |
+    Fresh | Erroneous | ImplicitCommon | Permanent | Synthetic |
     SuperAccessorOrScala2x | Inline
 
   /** Flags guaranteed to be set upon symbol creation, or, if symbol is a top-level
@@ -558,6 +552,9 @@ object Flags {
   /** A lazy or deferred value */
   final val LazyOrDeferred = Lazy | Deferred
 
+  /** An accessor or label */
+  final val AccessorOrLabel = Accessor | Label
+
   /** A synthetic or private definition */
   final val SyntheticOrPrivate = Synthetic | Private
 

compiler/src/dotty/tools/dotc/core/Phases.scala

@@ -305,6 +305,12 @@ object Phases {
      */
     def isTyper = false
 
+    /** Can this transform create or delete non-private members? */
+    def changesMembers: Boolean = false
+
+    /** Can this transform change the parents of a class? */
+    def changesParents: Boolean = false
+
     def exists: Boolean = true
 
     private var myPeriod: Period = Periods.InvalidPeriod
@@ -315,6 +321,8 @@ object Phases {
     private var mySymbolicRefs = false
     private var myLabelsReordered = false
 
+    private var mySameMembersStartId = NoPhaseId
+    private var mySameParentsStartId = NoPhaseId
 
     /** The sequence position of this phase in the given context where 0
      * is reserved for NoPhase and the first real phase is at position 1.
@@ -332,6 +340,11 @@ object Phases {
     final def symbolicRefs = mySymbolicRefs // Phase is after ResolveSuper, newly generated TermRefs should be symbolic
     final def labelsReordered = myLabelsReordered // Phase is after LabelDefs, labels are flattened and owner chains don't mirror this
 
+    final def sameMembersStartId = mySameMembersStartId
+      // id of first phase where all symbols are guaranteed to have the same members as in this phase
+    final def sameParentsStartId = mySameParentsStartId
+      // id of first phase where all symbols are guaranteed to have the same parents as in this phase
+
     protected[Phases] def init(base: ContextBase, start: Int, end:Int): Unit = {
       if (start >= FirstPhaseId)
         assert(myPeriod == Periods.InvalidPeriod, s"phase $this has already been used once; cannot be reused")
@@ -342,6 +355,8 @@ object Phases {
       myRefChecked   = prev.getClass == classOf[RefChecks]    || prev.refChecked
       mySymbolicRefs = prev.getClass == classOf[ResolveSuper] || prev.symbolicRefs
       myLabelsReordered = prev.getClass == classOf[LabelDefs] || prev.labelsReordered
+      mySameMembersStartId = if (changesMembers) id else prev.sameMembersStartId
+      mySameParentsStartId = if (changesParents) id else prev.sameMembersStartId
     }
 
     protected[Phases] def init(base: ContextBase, id: Int): Unit = init(base, id, id)