Introduce isCaptureChecking test

Author: odersky

compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -30,12 +30,24 @@ object ccConfig:
    */
   private[cc] val constrainRootsWhenMapping = true
 
-  val oldRefiningRoots = false
+  /** Use old scheme for refining vars, which should be no longer necessary
+   */
+  val oldRefiningVars = false
 end ccConfig
 
 def allowUniversalInBoxed(using Context) =
   Feature.sourceVersion.isAtLeast(SourceVersion.`3.3`)
 
+/** Are we at checkCaptures phase? */
+def isCaptureChecking(using Context): Boolean =
+  ctx.phaseId == Phases.checkCapturesPhase.id
+
+/** Are we at checkCaptures or Setup phase? */
+def isCaptureCheckingOrSetup(using Context): Boolean =
+  val ccId = Phases.checkCapturesPhase.id
+  val ctxId = ctx.phaseId
+  ctxId == ccId || ctxId == ccId - 1
+
 /** A dependent function type with given arguments and result type
  *  TODO Move somewhere else where we treat all function type related ops together.
  */

compiler/src/dotty/tools/dotc/cc/CapturingType.scala

@@ -56,10 +56,10 @@ object CapturingType:
   /** Decompose `tp` as a capturing type without taking IgnoreCaptures into account */
   def decomposeCapturingType(tp: Type)(using Context): Option[(Type, CaptureSet)] = tp match
     case AnnotatedType(parent, ann: CaptureAnnotation)
-    if ctx.phaseId <= Phases.checkCapturesPhase.id =>
+    if isCaptureCheckingOrSetup =>
       Some((parent, ann.refs))
     case AnnotatedType(parent, ann)
-    if ann.symbol == defn.RetainsAnnot && ctx.phase == Phases.checkCapturesPhase =>
+    if ann.symbol == defn.RetainsAnnot && isCaptureChecking =>
       // There are some circumstances where we cannot map annotated types
       // with retains annotations to capturing types, so this second recognizer
       // path still has to exist. One example is when checking capture sets

compiler/src/dotty/tools/dotc/cc/Synthetics.scala

@@ -7,7 +7,6 @@ import Symbols.*, SymDenotations.*, Contexts.*, Flags.*, Types.*, Decorators.*
 import StdNames.nme
 import Names.Name
 import NameKinds.DefaultGetterName
-import Phases.checkCapturesPhase
 import config.Printers.capt
 
 /** Classification and transformation methods for function methods and
@@ -75,7 +74,7 @@ object Synthetics:
      */
     def addCaptureDeps(info: Type): Type = info match
       case info: MethodType =>
-        val trackedParams = info.paramRefs.filter(atPhase(checkCapturesPhase)(_.isTracked))
+        val trackedParams = info.paramRefs.filter(atPhase(Phases.checkCapturesPhase)(_.isTracked))
         def augmentResult(tp: Type): Type = tp match
           case tp: MethodOrPoly =>
             tp.derivedLambdaType(resType = augmentResult(tp.resType))

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

@@ -657,7 +657,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         def compareRefined: Boolean =
           val tp1w = tp1.widen
 
-          if ctx.phase == Phases.checkCapturesPhase || ctx.phase == Phases.checkCapturesPhase.prev then
+          if isCaptureCheckingOrSetup then
 
             // A relaxed version of subtyping for dependent functions where method types
             // are treated as contravariant.
@@ -1013,10 +1013,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         def tp1widened =
           val tp1w = tp1.underlying.widenExpr
           tp1 match
-            case tp1: CaptureRef
-            if (ctx.phase == Phases.checkCapturesPhase || ctx.phase == Phases.checkCapturesPhase.prev)
-                && tp1.isTracked
-            =>
+            case tp1: CaptureRef if isCaptureCheckingOrSetup && tp1.isTracked =>
               CapturingType(tp1w.stripCapturing, tp1.singletonCaptureSet)
             case _ =>
               tp1w
@@ -2117,7 +2114,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             ExprType(info1.resType)
           case info1 => info1
 
-        if ccConfig.oldRefiningRoots && ctx.phase == Phases.checkCapturesPhase || ctx.phase == Phases.checkCapturesPhase.prev then
+        if ccConfig.oldRefiningVars && isCaptureCheckingOrSetup then
           // When comparing against a RefiningVar refinement, map the
           // localRoot of the corresponding class in `tp1` to the owner of the
           // refining capture set.
@@ -2262,7 +2259,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             val paramsMatch =
               if precise then
                 isSameTypeWhenFrozen(formal1, formal2a)
-              else if ctx.phase == Phases.checkCapturesPhase || ctx.phase == Phases.checkCapturesPhase.prev then
+              else if isCaptureCheckingOrSetup then
                 // allow to constrain capture set variables
                 isSubType(formal2a, formal1)
               else

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

@@ -36,7 +36,7 @@ import config.Printers.{core, typr, matchTypes}
 import reporting.{trace, Message}
 import java.lang.ref.WeakReference
 import compiletime.uninitialized
-import cc.{CapturingType, CaptureSet, derivedCapturingType, isBoxedCapturing, RetainingType, CaptureRoot}
+import cc.{CapturingType, CaptureSet, derivedCapturingType, isBoxedCapturing, RetainingType, CaptureRoot, isCaptureChecking}
 import CaptureSet.{CompareResult, IdempotentCaptRefMap, IdentityCaptRefMap}
 
 import scala.annotation.internal.sharable
@@ -2211,7 +2211,7 @@ object Types {
       else
         myCaptureSet = CaptureSet.Pending
         val computed = CaptureSet.ofInfo(this)
-        if ctx.phase != Phases.checkCapturesPhase || underlying.isProvisional then
+        if !isCaptureChecking || underlying.isProvisional then
           myCaptureSet = null
         else
           myCaptureSet = computed

compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala

@@ -8,6 +8,7 @@ import NameKinds.DefaultGetterName
 import NullOpsDecorator._
 import collection.immutable.BitSet
 import scala.annotation.tailrec
+import cc.isCaptureChecking
 
 /** A module that can produce a kind of iterator (`Cursor`),
  *  which yields all pairs of overriding/overridden symbols
@@ -31,7 +32,7 @@ object OverridingPairs:
      */
     protected def exclude(sym: Symbol): Boolean =
       !sym.memberCanMatchInheritedSymbols
-      || ctx.phase == Phases.checkCapturesPhase && sym.is(Recheck.ResetPrivate)
+      || isCaptureChecking && sym.is(Recheck.ResetPrivate)
 
     /** The parents of base that are checked when deciding whether an overriding
      *  pair has already been treated in a parent class.

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -39,6 +39,7 @@ import config.Feature.sourceVersion
 import config.SourceVersion._
 import printing.Formatting.hlAsKeyword
 import transform.TypeUtils.*
+import cc.isCaptureChecking
 
 import collection.mutable
 import reporting._
@@ -67,7 +68,7 @@ object Checking {
    */
   def checkBounds(args: List[tpd.Tree], boundss: List[TypeBounds],
     instantiate: (Type, List[Type]) => Type, app: Type = NoType, tpt: Tree = EmptyTree)(using Context): Unit =
-    if ctx.phase != Phases.checkCapturesPhase then
+    if !isCaptureChecking then
       args.lazyZip(boundss).foreach { (arg, bound) =>
         if !bound.isLambdaSub && !arg.tpe.hasSimpleKind then
           errorTree(arg,
@@ -152,7 +153,7 @@ object Checking {
             // if we attempt to check bounds of F-bounded mutually recursive Java interfaces.
             // Do check all bounds in Scala units and those bounds in Java units that
             // occur in applications of Scala type constructors.
-            && !(ctx.phase == Phases.checkCapturesPhase && !tycon.typeSymbol.is(CaptureChecked))
+            && !isCaptureChecking || tycon.typeSymbol.is(CaptureChecked)
             // Don't check bounds when capture checking type constructors that were not
             // themselves capture checked. Since the type constructor could not foresee
             // possible capture sets, it's better to be lenient for backwards compatibility.

compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala

@@ -14,6 +14,7 @@ import Implicits.{hasExtMethod, Candidate}
 import java.util.{Timer, TimerTask}
 import collection.mutable
 import scala.util.control.NonFatal
+import cc.isCaptureChecking
 
 /** This trait defines the method `importSuggestionAddendum` that adds an addendum
  *  to error messages suggesting additional imports.
@@ -319,7 +320,7 @@ trait ImportSuggestions:
    *  If there's nothing to suggest, an empty string is returned.
    */
   override def importSuggestionAddendum(pt: Type)(using Context): String =
-    if ctx.phase == Phases.checkCapturesPhase then
+    if isCaptureChecking then
       return "" // it's too late then to look for implicits
     val (fullMatches, headMatches) =
       importSuggestions(pt)(using ctx.fresh.setExploreTyperState())

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -20,7 +20,7 @@ import config.SourceVersion.{`3.0`, `future`}
 import config.Printers.refcheck
 import reporting._
 import Constants.Constant
-import cc.{mapRoots, localRoot}
+import cc.{mapRoots, localRoot, isCaptureChecking}
 
 object RefChecks {
   import tpd._
@@ -105,7 +105,7 @@ object RefChecks {
 
       def checkSelfConforms(other: ClassSymbol) =
         var otherSelf = other.declaredSelfTypeAsSeenFrom(cls.thisType)
-        if ctx.phase == Phases.checkCapturesPhase then
+        if isCaptureChecking then
           otherSelf = mapRoots(other.localRoot.termRef, cls.localRoot.termRef)(otherSelf)
             .showing(i"map self $otherSelf = $result", capt)
         if otherSelf.exists then