Store definition capture set information in class denotation

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

@@ -207,17 +207,6 @@ extension (tp: Type)
     case _: TypeRef | _: AppliedType => tp.typeSymbol.hasAnnotation(defn.CapabilityAnnot)
     case _ => false
 
-  /** Check if the class has universal capability, which means:
-   *  1. the class has a capability annotation,
-   *  2. the class is an impure function type,
-   *  3. or one of its base classes has universal capability.
-   */
-  def hasUniversalCapability(using Context): Boolean = tp match
-    case CapturingType(parent, ref) =>
-      ref.isUniversal || parent.hasUniversalCapability
-    case tp =>
-      tp.isCapabilityClassRef || tp.parents.exists(_.hasUniversalCapability)
-
   /** Drop @retains annotations everywhere */
   def dropAllRetains(using Context): Type = // TODO we should drop retains from inferred types before unpickling
     val tm = new TypeMap:

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

@@ -528,8 +528,7 @@ class CheckCaptures extends Recheck, SymTransformer:
          */
         def addParamArgRefinements(core: Type, initCs: CaptureSet): (Type, CaptureSet) =
           var refined: Type = core
-          var allCaptures: CaptureSet = if core.hasUniversalCapability
-            then CaptureSet.universal else initCs
+          var allCaptures: CaptureSet = core.classSymbol.denot.asClass.definitionCaptureSet ++ initCs
           for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
             val getter = cls.info.member(getterName).suchThat(_.is(ParamAccessor)).symbol
             if getter.termRef.isTracked && !getter.is(Private) then

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

@@ -290,11 +290,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
             if t1 ne t.ref then t1 else t
           case t: TypeVar =>
             this(t.underlying)
-          case t =>
+          case t: TypeRef =>
             // Map references to capability classes C to C^
-            if t.hasUniversalCapability
-            then CapturingType(t, defn.expandedUniversalSet, boxed = false)
-            else recur(t)
+            CapturingType(t, t.classSymbol.denot.asClass.definitionCaptureSet, boxed = false)
+          case t =>
+            recur(t)
     end expandAliases
 
     val tp1 = expandAliases(tp) // TODO: Do we still need to follow aliases?

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

@@ -23,7 +23,7 @@ import scala.util.control.NonFatal
 import config.Config
 import reporting.*
 import collection.mutable
-import cc.{CapturingType, derivedCapturingType, stripCapturing}
+import cc.{CaptureSet, CapturingType, derivedCapturingType, stripCapturing}
 
 import scala.annotation.internal.sharable
 import scala.compiletime.uninitialized
@@ -1820,6 +1820,8 @@ object SymDenotations {
     private var baseDataCache: BaseData = BaseData.None
     private var memberNamesCache: MemberNames = MemberNames.None
 
+    private var myDefinitionCaptureSet: CaptureSet | Null = null
+
     private def memberCache(using Context): EqHashMap[Name, PreDenotation] = {
       if (myMemberCachePeriod != ctx.period) {
         myMemberCache = EqHashMap()
@@ -2029,6 +2031,15 @@ object SymDenotations {
               && (base ne defn.NothingClass)
         )
 
+    final def definitionCaptureSet(using Context): CaptureSet =
+      if myDefinitionCaptureSet == null then
+        myDefinitionCaptureSet = if symbol.hasAnnotation(defn.CapabilityAnnot)
+          then CaptureSet.universal
+          else parentTypes.foldLeft[CaptureSet](CaptureSet.empty) { (set, parent) =>
+            set ++ parent.captureSet ++ parent.classSymbol.denot.asClass.definitionCaptureSet
+          }
+      myDefinitionCaptureSet.nn
+
     /** Is it possible that a class inherits both `this` and `that`?
      *
      *  @note The test is based on single-class inheritance and the closed