Avoid phase caches

Extra work would be needed to keep them up-to-date. In the end its easier
to just set speficic phases on initialization.

Author: odersky

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

@@ -149,6 +149,7 @@ object Phases {
       })
 
       phases = (NoPhase :: flatPhases.toList ::: new TerminalPhase :: Nil).toArray
+      setSpecificPhases()
       var phasesAfter:Set[Class[_ <: Phase]] = Set.empty
       nextDenotTransformerId = new Array[Int](phases.length)
       denotTransformers = new Array[DenotTransformer](phases.length)
@@ -211,53 +212,52 @@ object Phases {
       config.println(s"nextDenotTransformerId = ${nextDenotTransformerId.deep}")
     }
 
-    def phaseOfClass(pclass: Class[_]) = phases.find(pclass.isInstance).getOrElse(NoPhase)
-
-    private val cachedPhases = collection.mutable.Set[PhaseCache]()
-    private def cleanPhaseCache = cachedPhases.foreach(_.myPhase = NoPhase)
-
-    /** A cache to compute the phase with given name, which
-     *  stores the phase as soon as phaseNamed returns something
-     *  different from NoPhase.
-     */
-    private class PhaseCache(pclass: Class[_ <: Phase]) {
-      var myPhase: Phase = NoPhase
-      def phase = {
-        if (myPhase eq NoPhase) myPhase = phaseOfClass(pclass)
-        myPhase
-      }
-      cachedPhases += this
+    private var myTyperPhase: Phase = _
+    private var myPicklerPhase: Phase = _
+    private var myRefChecksPhase: Phase = _
+    private var myPatmatPhase: Phase = _
+    private var myElimRepeatedPhase: Phase = _
+    private var myExtensionMethodsPhase: Phase = _
+    private var myExplicitOuterPhase: Phase = _
+    private var myGettersPhase: Phase = _
+    private var myErasurePhase: Phase = _
+    private var myElimErasedValueTypePhase: Phase = _
+    private var myLambdaLiftPhase: Phase = _
+    private var myFlattenPhase: Phase = _
+    private var myGenBCodePhase: Phase = _
+
+    def typerPhase = myTyperPhase
+    def picklerPhase = myPicklerPhase
+    def refchecksPhase = myRefChecksPhase
+    def patmatPhase = myPatmatPhase
+    def elimRepeatedPhase = myElimRepeatedPhase
+    def extensionMethodsPhase = myExtensionMethodsPhase
+    def explicitOuterPhase = myExplicitOuterPhase
+    def gettersPhase = myGettersPhase
+    def erasurePhase = myErasurePhase
+    def elimErasedValueTypePhase = myElimErasedValueTypePhase
+    def lambdaLiftPhase = myLambdaLiftPhase
+    def flattenPhase = myFlattenPhase
+    def genBCodePhase = myGenBCodePhase
+
+    private def setSpecificPhases() = {
+      def phaseOfClass(pclass: Class[_]) = phases.find(pclass.isInstance).getOrElse(NoPhase)
+
+      myTyperPhase = phaseOfClass(classOf[FrontEnd])
+      myPicklerPhase = phaseOfClass(classOf[Pickler])
+      myRefChecksPhase = phaseOfClass(classOf[RefChecks])
+      myElimRepeatedPhase = phaseOfClass(classOf[ElimRepeated])
+      myExtensionMethodsPhase = phaseOfClass(classOf[ExtensionMethods])
+      myErasurePhase = phaseOfClass(classOf[Erasure])
+      myElimErasedValueTypePhase = phaseOfClass(classOf[ElimErasedValueType])
+      myPatmatPhase = phaseOfClass(classOf[PatternMatcher])
+      myLambdaLiftPhase = phaseOfClass(classOf[LambdaLift])
+      myFlattenPhase = phaseOfClass(classOf[Flatten])
+      myExplicitOuterPhase = phaseOfClass(classOf[ExplicitOuter])
+      myGettersPhase = phaseOfClass(classOf[Getters])
+      myGenBCodePhase =  phaseOfClass(classOf[GenBCode])
     }
 
-    private val typerCache = new PhaseCache(classOf[FrontEnd])
-    private val picklerCache = new PhaseCache(classOf[Pickler])
-
-    private val refChecksCache = new PhaseCache(classOf[RefChecks])
-    private val elimRepeatedCache = new PhaseCache(classOf[ElimRepeated])
-    private val extensionMethodsCache = new PhaseCache(classOf[ExtensionMethods])
-    private val erasureCache = new PhaseCache(classOf[Erasure])
-    private val elimErasedValueTypeCache = new PhaseCache(classOf[ElimErasedValueType])
-    private val patmatCache = new PhaseCache(classOf[PatternMatcher])
-    private val lambdaLiftCache = new PhaseCache(classOf[LambdaLift])
-    private val flattenCache = new PhaseCache(classOf[Flatten])
-    private val explicitOuterCache = new PhaseCache(classOf[ExplicitOuter])
-    private val gettersCache = new PhaseCache(classOf[Getters])
-    private val genBCodeCache = new PhaseCache(classOf[GenBCode])
-
-    def typerPhase = typerCache.phase
-    def picklerPhase = picklerCache.phase
-    def refchecksPhase = refChecksCache.phase
-    def elimRepeatedPhase = elimRepeatedCache.phase
-    def extensionMethodsPhase = extensionMethodsCache.phase
-    def erasurePhase = erasureCache.phase
-    def elimErasedValueTypePhase = elimErasedValueTypeCache.phase
-    def patmatPhase = patmatCache.phase
-    def lambdaLiftPhase = lambdaLiftCache.phase
-    def flattenPhase = flattenCache.phase
-    def explicitOuterPhase = explicitOuterCache.phase
-    def gettersPhase = gettersCache.phase
-    def genBCodePhase = genBCodeCache.phase
-
     def isAfterTyper(phase: Phase): Boolean = phase.id > typerPhase.id
   }