Fix CaptureSet.ofInfo for capture variables

This change now makes both the tests cc-poly-varargs and capturesubtyping
pass.

- Move CapSet-related methods to CaptureOps
- Let NamedType case in secondTry of TypeComparer handle capture variables as well
- Added a case in capturesubtyping test to test forgotten NamedType case above

Author: bracevac

Diff for: compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -170,6 +170,32 @@ extension (tree: Tree)
 
 extension (tp: Type)
 
+  /**
+   * Is the type `tp` a `CapSet` type, i.e., a capture variable?
+   *
+   * @param tp The type to check
+   * @param includeCapSet Whether to include the bare `CapSet` type itself in the check, false at the top level
+   */
+  final def isCapSet(includeCapSet: Boolean = false)(using Context): Boolean = tp match
+    case tp: TypeRef => (includeCapSet && (tp.symbol eq defn.Caps_CapSet)) || {
+      tp.underlying match
+        case TypeBounds(lo, hi) => lo.isCapSet(true) && hi.isCapSet(true)
+        case TypeAlias(alias)   => alias.isCapSet() // TODO: test cases involving type aliases
+        case _                  => false
+    }
+    case tp: SingletonType => tp.underlying.isCapSet()
+    case CapturingType(parent, _) => parent.isCapSet(true)
+    case _ => false
+
+  /**
+   * The capture set of a capture variable. Assumes that tp.isCapSet() is true.
+   */
+  final def captureSetOfCapSet(using Context): CaptureSet = tp match
+    case CapturingType(_,c) => c
+    case tp: TypeRef if tp.symbol eq defn.Caps_CapSet => CaptureSet.empty
+    case tp: SingletonType => tp.underlying.captureSetOfCapSet
+    case tp: CaptureRef => CaptureSet(tp)
+
   /** Is this type a CaptureRef that can be tracked?
    *  This is true for
    *    - all ThisTypes and all TermParamRef,

Diff for: compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -1073,6 +1073,9 @@ object CaptureSet:
     case ReachCapability(ref1) =>
       ref1.widen.deepCaptureSet(includeTypevars = true)
         .showing(i"Deep capture set of $ref: ${ref1.widen} = ${result}", capt)
+    case tp : TypeRef if tp.isCapSet() => tp.underlying match
+      case TypeBounds(lo, hi) if hi.isCapSet() => hi.captureSetOfCapSet
+      case _ => ofType(ref.underlying, followResult = true)
     case _ =>
       if ref.isMaxCapability then ref.singletonCaptureSet
       else ofType(ref.underlying, followResult = true)

Diff for: compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -298,34 +298,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       }
     }
 
-     //TODO move the following functions somewhere more appropriate
-    /**
-     * Is the type `tp` a `CapSet` type, i.e., a capture variable?
-     *
-     * @param tp The type to check
-     * @param includeCapSet Whether to include the bare `CapSet` type itself in the check, false at the top level
-     */
-    def isCapSet(tp: Type, includeCapSet: Boolean = false): Boolean = tp match {
-      case tp: TypeRef => (includeCapSet && (tp.symbol eq defn.Caps_CapSet)) || {
-        tp.underlying match
-          case TypeBounds(lo, hi) => isCapSet(lo, true) && isCapSet(hi, true)
-          case TypeAlias(alias)   => isCapSet(alias) // TODO: test cases involving type aliases
-          case _                  => false
-      }
-      case tp: SingletonType => isCapSet(tp.underlying)
-      case CapturingType(parent, _) => isCapSet(parent, true)
-      case _ => false
-    }
-
-    /**
-     * Assumes that isCapSet(tp) is true.
-     */
-    def captureSet(tp: Type): CaptureSet = tp match
-      case CapturingType(_,c) => c
-      case tp: TypeRef if tp.symbol eq defn.Caps_CapSet => CaptureSet.empty
-      case tp: SingletonType => captureSet(tp.underlying)
-      case tp: CaptureRef => CaptureSet(tp)
-
     /** In capture checking, implements the logic to compare type variables which represent
      *  capture variables.
      *
@@ -335,8 +307,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
      *           0 if both tp1 and tp2 are capture variables but tp1 is not a subcapture of tp2.
      */
     inline def tryHandleCaptureVars: Int =
-      if !(isCaptureCheckingOrSetup && isCapSet(tp1) && isCapSet(tp2)) then -1
-      else if (captureSet(tp1).subCaptures(captureSet(tp2), frozenConstraint).isOK) then 1
+      if !(isCaptureCheckingOrSetup && tp1.isCapSet() && tp2.isCapSet()) then -1
+      else if (subCaptures(tp1.captureSetOfCapSet, tp2.captureSetOfCapSet, frozenConstraint).isOK) then 1
       else 0
 
     def firstTry: Boolean = tp2 match {
@@ -389,7 +361,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
                 && !(sym1.isClass && sym2.isClass)  // class types don't subtype each other
                 || {val cv = tryHandleCaptureVars
                     if (cv < 0) then thirdTryNamed(tp2)
-                    else cv > 0 }
+                    else cv != 0 }
             case _ =>
               secondTry
         end compareNamed
@@ -477,6 +449,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
     def secondTry: Boolean = tp1 match {
       case tp1: NamedType =>
+        val cv = tryHandleCaptureVars
+        if (cv >= 0) then return cv != 0
         tp1.info match {
           case info1: TypeAlias =>
             if (recur(info1.alias, tp2)) return true

Diff for: tests/neg-custom-args/captures/capture-vars-subtyping.scala

@@ -28,6 +28,7 @@ def testTrans[C^, D >: CapSet <: C, E >: CapSet <: D, F >: C <: CapSet^] =
   val c4: C = f1     // error
   val e4: E = f1     // error
   val e5: E = d1     // error
+  val c4: CapSet^{C^} = e1
 
 
 trait A[+T]