Delete Period.phaseId, force explicit use of first/last

Author: SolalPirelli

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -398,7 +398,7 @@ trait BCodeHelpers(val backendUtils: BackendUtils)(using ctx: Context) extends B
       atPhase(erasurePhase) {
         def computeMemberTpe(): Type =
           if (sym.is(Method)) sym.denot.info
-          else if sym.denot.validFor.phaseId > erasurePhase.id && sym.isField && sym.getter.exists then
+          else if sym.denot.validFor.firstPhaseId > erasurePhase.id && sym.isField && sym.getter.exists then
             // Memoization field of getter entered after erasure, see run/i17069 for an example
             sym.getter.denot.info.resultType
           else owner.denot.thisType.memberInfo(sym)

compiler/src/dotty/tools/backend/jvm/CoreBTypesFromSymbols.scala

@@ -211,7 +211,7 @@ final class CoreBTypesFromSymbols(val ppa: PostProcessorFrontendAccess)(using va
         if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None
         else {
           val original = innerClassSym.initial
-          Some(atPhase(original.validFor.phaseId)(innerClassSym.name).mangledString) // moduleSuffix for module classes
+          Some(atPhase(original.validFor.firstPhaseId)(innerClassSym.name).mangledString) // moduleSuffix for module classes
         }
       }
 

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -80,7 +80,7 @@ object DottyBackendInterface {
           // for example by specialization
           val original = toDenot(sym).initial
           val validity = original.validFor
-          atPhase(validity.phaseId) {
+          atPhase(validity.firstPhaseId) {
             toDenot(sym).isStatic
           }
         }
@@ -90,7 +90,7 @@ object DottyBackendInterface {
         // it is very tricky in presence of classes(and anonymous classes) defined inside supper calls.
         if (sym.exists) {
           val validity = toDenot(sym).initial.validFor
-          atPhase(validity.phaseId) {
+          atPhase(validity.firstPhaseId) {
             toDenot(sym).lexicallyEnclosingClass
           }
         } else NoSymbol

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

@@ -355,7 +355,7 @@ object Contexts {
 
     final def phase: Phase = base.phases(period.firstPhaseId)
     final def runId = period.runId
-    final def phaseId = period.phaseId
+    final def phaseId = period.firstPhaseId
 
     final def lastPhaseId = base.phases.length - 1
 

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

@@ -26,8 +26,8 @@ object Periods {
     val period = ctx.period
     period == p ||
     period.runId == p.runId &&
-      unfusedPhases(period.phaseId).sameBaseTypesStartId ==
-      unfusedPhases(p.phaseId).sameBaseTypesStartId
+      unfusedPhases(period.firstPhaseId).sameBaseTypesStartId ==
+      unfusedPhases(p.firstPhaseId).sameBaseTypesStartId
 
   /** A period is a contiguous sequence of phase ids in some run.
    *  It is coded as follows:
@@ -43,9 +43,6 @@ object Periods {
     /** The run identifier of this period. */
     def runId: RunId = code >>> (PhaseWidth * 2)
 
-    /** The phase identifier of this single-phase period. */
-    def phaseId: PhaseId = firstPhaseId
-
     /** The last phase of this period */
     def lastPhaseId: PhaseId = (code >>> PhaseWidth) & PhaseMask
 

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

@@ -2967,8 +2967,8 @@ object SymDenotations {
     def isValidAt(phase: Phase)(using Context) =
       checkedPeriod == ctx.period ||
         createdAt.runId == ctx.runId &&
-        createdAt.phaseId < unfusedPhases.length &&
-        sameGroup(unfusedPhases(createdAt.phaseId), phase) &&
+        createdAt.firstPhaseId < unfusedPhases.length &&
+        sameGroup(unfusedPhases(createdAt.firstPhaseId), phase) &&
         { checkedPeriod = ctx.period; true }
   }
 

compiler/test/dotty/tools/dotc/core/PeriodsTest.scala

@@ -0,0 +1,40 @@
+package dotty.tools.dotc.core
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class PeriodsTest:
+  import Periods._
+
+  val p1 = Period(1, 2, 7)
+  val p2 = Period(1, 3, 7)
+
+  @Test def containsSubsetIsTrue() =
+    assertTrue(p1.contains(p2))
+
+  @Test def containsSelfIsTrue() =
+    assertTrue(p1.contains(p1))
+
+  @Test def containsSupersetIsFalse() =
+    assertFalse(p2.contains(p1))
+
+  @Test def containsInvalidIsFalse() =
+    assertFalse(p1.contains(Period(0, 3, 3)))
+
+  @Test def containsDifferentRunIsFalse() =
+    assertFalse(p1.contains(Period(2, 3, 3)))
+
+  @Test def containsNowhereIsFalse() =
+    assertFalse(p1.contains(Nowhere))
+
+  @Test def overlapsSelfIsTrue() =
+    assertTrue(p1.overlaps(p1))
+
+  @Test def overlapsOverlappingIsTrue() =
+    assertTrue(Period(1, 2, 7).overlaps(Period(1, 6, 9)))
+
+  @Test def overlapsNonOverlappingIsFalse() =
+    assertTrue(Period(1, 2, 5).overlaps(Period(1, 6, 9)))
+
+  @Test def overlapsDifferentRunIsFalse() =
+    assertTrue(Period(1, 2, 7).overlaps(Period(2, 6, 9)))