Handle TypeVars in CaptureSets

Author: odersky

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

@@ -17,23 +17,6 @@ case class CaptureSet private (elems: CaptureSet.Refs) extends Showable:
   def isEmpty: Boolean = elems.isEmpty
   def nonEmpty: Boolean = !isEmpty
 
-  private var myClosure: Refs | Null = null
-
-  def closure(using Context): Refs =
-    if myClosure == null then
-      var cl = elems
-      var seen: Refs = SimpleIdentitySet.empty
-      while
-        val prev = cl
-        for ref <- cl do
-          if !seen.contains(ref) then
-            seen += ref
-            cl = cl ++ ref.captureSetOfInfo.elems
-        prev ne cl
-      do ()
-      myClosure = cl
-    myClosure
-
   def ++ (that: CaptureSet): CaptureSet =
     if this.isEmpty then that
     else if that.isEmpty then this
@@ -101,9 +84,7 @@ object CaptureSet:
 
   def ofType(tp: Type)(using Context): CaptureSet =
     def recur(tp: Type): CaptureSet = tp match
-      case tp: NamedType =>
-        tp.captureSet
-      case tp: ParamRef =>
+      case tp: CaptureRef =>
         tp.captureSet
       case CapturingType(parent, ref) =>
         recur(parent) + ref

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

@@ -3620,7 +3620,7 @@ object Types {
           case tp: TermParamRef if tp.binder eq thisLambdaType => TrueDeps
           case tp: CapturingType =>
             val status1 = compute(status, tp.parent, theAcc)
-            tp.ref match
+            tp.ref.stripTypeVar match
               case tp: TermParamRef if tp.binder eq thisLambdaType => combine(status1, CaptureDeps)
               case _ => status1
           case _: ThisType | _: BoundType | NoPrefix => status
@@ -4505,9 +4505,10 @@ object Types {
    *  @param  origin        The parameter that's tracked by the type variable.
    *  @param  creatorState  The typer state in which the variable was created.
    */
-  final class TypeVar private(initOrigin: TypeParamRef, creatorState: TyperState, nestingLevel: Int) extends CachedProxyType with ValueType {
+  final class TypeVar private(initOrigin: TypeParamRef, creatorState: TyperState, nestingLevel: Int)
+  extends CachedProxyType, CaptureRef {
 
-    private var currentOrigin = initOrigin
+   private var currentOrigin = initOrigin
 
     def origin: TypeParamRef = currentOrigin
 
@@ -4689,6 +4690,26 @@ object Types {
       if (inst.exists) inst else origin
     }
 
+    // Capture ref methods
+
+    def canBeTracked(using Context): Boolean = underlying match
+      case ref: CaptureRef => ref.canBeTracked
+      case _ => false
+
+    override def normalizedRef(using Context): CaptureRef = instanceOpt match
+      case ref: CaptureRef => ref
+      case _ => this
+
+    override def singletonCaptureSet(using Context) = instanceOpt match
+      case ref: CaptureRef => ref.singletonCaptureSet
+      case _ => super.singletonCaptureSet
+
+    override def captureSetOfInfo(using Context): CaptureSet = instanceOpt match
+      case ref: CaptureRef => ref.captureSetOfInfo
+      case tp => tp.captureSet
+
+    // Object members
+
     override def computeHash(bs: Binders): Int = identityHash(bs)
     override def equals(that: Any): Boolean = this.eq(that.asInstanceOf[AnyRef])
 

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

@@ -99,10 +99,12 @@ class CheckCaptures extends RefineTypes:
   def checkWellFormed(whole: Type, pos: SrcPos)(using Context): Unit =
     def checkRelativeVariance(mt: MethodType) = new TypeTraverser:
       def traverse(tp: Type): Unit = tp match
-        case CapturingType(parent, ref @ TermParamRef(`mt`, _)) =>
-          if variance <= 0 then
-            val direction = if variance < 0 then "contra" else "in"
-            report.error(em"captured reference $ref appears ${direction}variantly in type $whole", pos)
+        case CapturingType(parent, ref) =>
+          ref.stripTypeVar match
+            case ref @ TermParamRef(`mt`, _) if variance <= 0 =>
+              val direction = if variance < 0 then "contra" else "in"
+              report.error(em"captured reference $ref appears ${direction}variantly in type $whole", pos)
+            case _ =>
           traverse(parent)
         case _ =>
           traverseChildren(tp)

tests/neg-custom-args/captures/try3.scala

@@ -3,7 +3,7 @@ import java.io.IOException
 class CanThrow[E] extends Retains[*]
 type Top  = Any retains *
 
-def handle[E <: Exception, T <: Top](op: CanThrow[E] ?=> T)(handler: E => T): T =
+def handle[E <: Exception, T <: Top](op: (CanThrow[E] ?=> T) retains T)(handler: (E => T) retains T): T =
   val x: CanThrow[E] = ???
   try op(using x)
   catch case ex: E => handler(ex)