Drop BoxedTypeCache

Author: odersky

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

@@ -15,7 +15,6 @@ import config.Feature
 import collection.mutable
 
 private val Captures: Key[CaptureSet] = Key()
-private val BoxedType: Key[BoxedTypeCache] = Key()
 
 object ccConfig:
 
@@ -25,14 +24,6 @@ object ccConfig:
    */
   private[cc] val adaptUnpickledFunctionTypes = false
 
-  /** Switch whether we constrain a root var that includes the source of a
-   *  root map to be an alias of that source (so that it can be mapped)
-   */
-  private[cc] val constrainRootsWhenMapping = true
-
-  /** Use old scheme for refining vars, which should be no longer necessary
-   */
-  val oldRefiningVars = false
 end ccConfig
 
 def allowUniversalInBoxed(using Context) =
@@ -132,21 +123,15 @@ extension (tp: Type)
       if (parent eq p) && (refs eq r) then tp
       else CapturingType(parent, refs, tp.isBoxed)
 
-  // TODO Move boxed/unboxed to CaapturingType?
   /** If this is a unboxed capturing type with nonempty capture set, its boxed version.
    *  Or, if type is a TypeBounds of capturing types, the version where the bounds are boxed.
    *  The identity for all other types.
    */
   def boxed(using Context): Type = tp.dealias match
     case tp @ CapturingType(parent, refs) if !tp.isBoxed && !refs.isAlwaysEmpty =>
       tp.annot match
-        case ann: CaptureAnnotation =>
-          AnnotatedType(parent, ann.boxedAnnot)
-        case ann =>
-          ann.tree.getAttachment(BoxedType) match // TODO drop
-            case None => ann.tree.putAttachment(BoxedType, BoxedTypeCache())
-            case _ =>
-          ann.tree.attachment(BoxedType)(tp)
+        case ann: CaptureAnnotation => AnnotatedType(parent, ann.boxedAnnot)
+        case ann => tp
     case tp: RealTypeBounds =>
       tp.derivedTypeBounds(tp.lo.boxed, tp.hi.boxed)
     case _ =>

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

@@ -56,7 +56,7 @@ sealed abstract class CaptureSet extends Showable:
    */
   def isAlwaysEmpty: Boolean
 
-  /** An optinal level limit, or NoSymbol if none exists. All elements of the set
+  /** An optional level limit, or NoSymbol if none exists. All elements of the set
    *  must be in scopes visible from the level limit.
    */
   def levelLimit: Symbol
@@ -78,13 +78,11 @@ sealed abstract class CaptureSet extends Showable:
 
   /** Does this capture set contain the root reference `cap` as element? */
   final def isUniversal(using Context) =
-    elems.exists(_.isGenericRootCapability)
+    elems.exists(_.isUniversalRootCapability)
 
   /** Does this capture set contain the root reference `cap` as element? */
   final def containsRoot(using Context) =
-    elems.exists:
-      case ref: TermRef => ref.isRootCapability
-      case _ => false
+    elems.exists(_.isRootCapability)
 
   final def disallowsUniversal(using Context) =
     if isConst then !isUniversal && elems.exists(_.isLocalRootCapability)
@@ -144,7 +142,7 @@ sealed abstract class CaptureSet extends Showable:
       || y.match
           case y: TermRef => y.prefix eq x
           case _ => false
-      || (x.isGenericRootCapability || y.isRootCapability && x.isRootCapability)
+      || (x.isUniversalRootCapability || y.isRootCapability && x.isRootCapability)
           && ctx.property(LooseRootChecking).isDefined
 
     /** x <:< cap,   cap[x] <:< cap
@@ -153,8 +151,8 @@ sealed abstract class CaptureSet extends Showable:
      */
     private def isSuperRootOf(y: CaptureRef): Boolean = x match
       case x: TermRef =>
-        if x.isGenericRootCapability then true
-        else if x.isLocalRootCapability && !y.isGenericRootCapability then
+        if x.isUniversalRootCapability then true
+        else if x.isLocalRootCapability && !y.isUniversalRootCapability then
           val xowner = x.localRootOwner
           y match
             case y: TermRef =>
@@ -287,11 +285,6 @@ sealed abstract class CaptureSet extends Showable:
       else Const(elems.filter(p))
     else Filtered(asVar, p)
 
-  /** This set with a new owner and therefore also a new levelLimit */
-  def changeOwner(newOwner: Symbol)(using Context): CaptureSet =
-    if this.isConst then this
-    else ChangedOwner(asVar, newOwner)
-
   /** Capture set obtained by applying `tm` to all elements of the current capture set
    *  and joining the results. If the current capture set is a variable, the same
    *  transformation is applied to all future additions of new elements.
@@ -517,7 +510,7 @@ object CaptureSet:
       else
         //assert(id != 19 || !elem.isLocalRootCapability, elem.asInstanceOf[TermRef].localRootOwner)
         elems += elem
-        if elem.isGenericRootCapability then rootAddedHandler()
+        if elem.isUniversalRootCapability then rootAddedHandler()
         newElemAddedHandler(elem)
         // assert(id != 5 || elems.size != 3, this)
         val res = (CompareResult.OK /: deps) { (r, dep) =>
@@ -527,7 +520,7 @@ object CaptureSet:
         res
 
     private def levelOK(elem: CaptureRef)(using Context): Boolean =
-      if elem.isGenericRootCapability then !noUniversal
+      if elem.isUniversalRootCapability then !noUniversal
       else !levelLimit.exists
       || elem.match
           case elem: TermRef =>
@@ -560,7 +553,7 @@ object CaptureSet:
 
     /** Roughly: the intersection of all constant known supersets of this set.
      *  The aim is to find an as-good-as-possible constant set that is a superset
-     *  of this set. The associated root set {cap[owner]} is a sound fallback.
+     *  of this set. The universal set {cap} is a sound fallback.
      */
     final def upperApprox(origin: CaptureSet)(using Context): CaptureSet =
       if isConst then this
@@ -758,10 +751,6 @@ object CaptureSet:
     override def toString = s"BiMapped$id($source, elems = $elems)"
   end BiMapped
 
-  /** Same as `source` but with a new directOwner */
-  class ChangedOwner private[CaptureSet](val source: Var, newOwner: Symbol)(using @constructorOnly ctx: Context)
-  extends DerivedVar(newOwner, source.elems)
-
   /** A variable with elements given at any time as { x <- source.elems | p(x) } */
   class Filtered private[CaptureSet]
     (val source: Var, p: Context ?=> CaptureRef => Boolean)(using @constructorOnly ctx: Context)
@@ -1087,7 +1076,7 @@ object CaptureSet:
     override def toAdd(using Context) =
       for CompareResult.LevelError(cs, ref) <- ccState.levelError.toList yield
         ccState.levelError = None
-        if ref.isGenericRootCapability then
+        if ref.isUniversalRootCapability then
           i"""
             |
             |Note that the universal capability `cap`

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

@@ -28,7 +28,7 @@ object CapturingType:
 
   /** Smart constructor that
    *   - drops empty capture sets
-   *   - drops capability class ecpansion if they are refined with another capturing type
+   *   - drops a capability class expansion if it is further refined with another capturing type
    *   - fuses compatible capturiong types.
    *  An outer type capturing type A can be fused with an inner capturing type B if their
    *  boxing status is the same or if A is boxed.
@@ -77,7 +77,7 @@ object CapturingType:
       None
 
   /** Check whether a type is uncachable when computing `baseType`.
-   * We avoid caching capturing types when IgnoreCaptures mode is set, since the
+   *  We avoid caching capturing types when IgnoreCaptures mode is set.
    */
   def isUncachable(tp: Type)(using Context): Boolean =
     ctx.mode.is(Mode.IgnoreCaptures) && decomposeCapturingType(tp).isDefined

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

@@ -140,7 +140,10 @@ object CheckCaptures:
           case tpe =>
             report.error(em"$elem: $tpe is not a legal element of a capture set", elem.srcPos)
 
-  /** Report an error if some part of `tp` contains the root capability in its capture set */
+  /** Report an error if some part of `tp` contains the root capability in its capture set
+   *  or if it refers to an unsealed type parameter that could possibly be instantiated with
+   *  cap in a way that's visible at the type.
+   */
   def disallowRootCapabilitiesIn(tp: Type, carrier: Symbol, what: String, have: String, addendum: String, pos: SrcPos)(using Context) =
     val check = new TypeTraverser:
       extension (tparam: Symbol) def isParametricIn(carrier: Symbol): Boolean =
@@ -195,7 +198,6 @@ class CheckCaptures extends Recheck, SymTransformer:
   def phaseName: String = "cc"
 
   override def isRunnable(using Context) = super.isRunnable && Feature.ccEnabledSomewhere
-  override def firstPrepPhase = preRecheckPhase
 
   def newRechecker()(using Context) = CaptureChecker(ctx)
 
@@ -525,7 +527,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             augmentConstructorType(parent, initCs ++ refs)
           case _ =>
             val (refined, cs) = addParamArgRefinements(core, initCs)
-            refined.capturing(cs.changeOwner(ctx.owner))
+            refined.capturing(cs)
 
         augmentConstructorType(ownType, capturedVars(cls) ++ capturedVars(sym))
           .showing(i"constr type $mt with $argTypes%, % in $cls = $result", capt)
@@ -675,12 +677,6 @@ class CheckCaptures extends Recheck, SymTransformer:
       super.recheckTyped(tree)
 
     override def recheckTry(tree: Try, pt: Type)(using Context): Type =
-/*
-      val saved = curEnv
-      curEnv = Env(tryOwner, EnvKind.Regular, CaptureSet.Var(curEnv.owner), curEnv)
-      val tp =
-        try super.recheckTry(tree, pt)
-        finally curEnv = saved*/
       val tp = super.recheckTry(tree, pt)
       if allowUniversalInBoxed && Feature.enabled(Feature.saferExceptions) then
         disallowRootCapabilitiesIn(tp, ctx.owner,
@@ -805,7 +801,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           .showing(i"adapt universal $actual vs $expected = $result", capt)
       else actual
 
-    val debugSuccesses = false
+    private inline val debugSuccesses = false
 
     /** Massage `actual` and `expected` types before checking conformance.
      *  Massaging is done by the methods following this one:

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

@@ -311,12 +311,9 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
             if sym.isClass then t
             else t.info match
               case TypeAlias(alias) =>
-                val transformed =
-                  if sym.isStatic || true then this(alias)
-                  else transformExplicitType(alias)(
-                    using ctx.withOwner(sym.owner))
+                val transformed = this(alias)
                 if transformed ne alias then transformed else t
-                    //.showing(i"EXPAND $t with ${t.info} to $result in ${t.symbol.owner}/${ctx.owner}")
+                  //.showing(i"EXPAND $t with ${t.info} to $result in ${t.symbol.owner}/${ctx.owner}")
               case _ =>
                 recur(t)
           case t @ AppliedType(tycon: TypeProxy, args) if true =>

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

@@ -2182,7 +2182,7 @@ object Types {
       isTrackableRef && (isRootCapability || !captureSetOfInfo.isAlwaysEmpty)
 
     /** Is this reference the generic root capability `cap` ? */
-    def isGenericRootCapability(using Context): Boolean = false
+    def isUniversalRootCapability(using Context): Boolean = false
 
     /** Is this reference a local root capability `{<cap in owner>}`
      *  for some level owner?
@@ -2193,7 +2193,7 @@ object Types {
 
     /** Is this reference the a (local or generic) root capability? */
     def isRootCapability(using Context): Boolean =
-      isGenericRootCapability || isLocalRootCapability
+      isUniversalRootCapability || isLocalRootCapability
 
     /** Normalize reference so that it can be compared with `eq` for equality */
     def normalizedRef(using Context): CaptureRef = this
@@ -2927,7 +2927,7 @@ object Types {
       || isRootCapability
       ) && !symbol.isOneOf(UnstableValueFlags)
 
-    override def isGenericRootCapability(using Context): Boolean =
+    override def isUniversalRootCapability(using Context): Boolean =
       name == nme.CAPTURE_ROOT && symbol == defn.captureRoot
 
     def localRootOwner(using Context): Symbol =