Fix subCapture in frozen state

Previously, we still OKed two empty variables to be compared with
subcapture in the frozen state. This should give an error.

Author: odersky

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

@@ -7,6 +7,7 @@ import Types.*, Symbols.*, Flags.*, Contexts.*, Decorators.*
 import config.Printers.capt
 import Annotations.Annotation
 import annotation.threadUnsafe
+import annotation.constructorOnly
 import annotation.internal.sharable
 import reporting.trace
 import printing.{Showable, Printer}
@@ -58,11 +59,11 @@ sealed abstract class CaptureSet extends Showable:
   protected def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult
 
   /** If this is a variable, add `cs` as a super set */
-  protected def addSuper(cs: CaptureSet): this.type
+  protected def addSuper(cs: CaptureSet)(using Context, VarState): CompareResult
 
   /** If `cs` is a variable, add this capture set as one of its super sets */
-  protected def addSub(cs: CaptureSet): this.type =
-    cs.addSuper(this)
+  protected def addSub(cs: CaptureSet)(using Context): this.type =
+    cs.addSuper(this)(using ctx, UnrecordedState)
     this
 
   /** Try to include all references of `elems` that are not yet accounted by this
@@ -81,18 +82,20 @@ sealed abstract class CaptureSet extends Showable:
   def accountsFor(x: CaptureRef)(using Context): Boolean =
     reporting.trace(i"$this accountsFor $x, ${x.captureSetOfInfo}?", show = true) {
       elems.contains(x)
-      || !x.isRootCapability
-          && x.captureSetOfInfo.subCaptures(this, frozen = true) == CompareResult.OK
+      || !x.isRootCapability && x.captureSetOfInfo.elems.forall(accountsFor)
     }
 
   /** The subcapturing test */
-  def subCaptures(that: CaptureSet, frozen: Boolean)(using Context): CompareResult =
+  final def subCaptures(that: CaptureSet, frozen: Boolean)(using Context): CompareResult =
     subCaptures(that)(using ctx, if frozen then FrozenState else VarState())
 
   private def subCaptures(that: CaptureSet)(using Context, VarState): CompareResult =
     val result = that.tryInclude(elems, this)
-    if result == CompareResult.OK then addSuper(that) else varState.abort()
-    result
+    if result == CompareResult.OK then
+      addSuper(that)
+    else
+      varState.abort()
+      result
 
   def =:= (that: CaptureSet)(using Context): Boolean =
        this.subCaptures(that, frozen = true) == CompareResult.OK
@@ -201,7 +204,7 @@ object CaptureSet:
     def addNewElems(elems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
       CompareResult.fail(this)
 
-    def addSuper(cs: CaptureSet) = this
+    def addSuper(cs: CaptureSet)(using Context, VarState) = CompareResult.OK
 
     override def toString = elems.toString
   end Const
@@ -244,7 +247,14 @@ object CaptureSet:
       else
         CompareResult.fail(this)
 
-    def addSuper(cs: CaptureSet) = { deps += cs; this }
+    def addSuper(cs: CaptureSet)(using Context, VarState): CompareResult =
+      if (cs eq this) || cs.elems.contains(defn.captureRoot.termRef) then
+        CompareResult.OK
+      else if recordDepsState() then
+        deps += cs
+        CompareResult.OK
+      else
+        CompareResult.fail(this)
 
     override def toString = s"Var$id$elems"
   end Var
@@ -254,7 +264,7 @@ object CaptureSet:
    */
   class Mapped private[CaptureSet] (
       cv: Var, tm: TypeMap, variance: Int, initial: CaptureSet
-    ) extends Var(initial.elems):
+    )(using @constructorOnly ctx: Context) extends Var(initial.elems):
     addSub(cv)
     addSub(initial)
     val stack = if debugSets then (new Throwable).getStackTrace().take(20) else null
@@ -271,21 +281,21 @@ object CaptureSet:
           mapRefs(newElems, tm, variance)
         else
           if variance <= 0 && !origin.isConst && (origin ne initial) then
-            report.error(i"trying to add elems $newElems to $this from unrecognized source of mapped set $this$whereCreated")
+            report.warning(i"trying to add elems $newElems to $this from unrecognized source of mapped set $this$whereCreated")
           Const(newElems)
       val result = super.addNewElems(added.elems, origin)
       if result == CompareResult.OK then
         added match
           case added: Var =>
-            added.recordDepsState()
-            addSub(added)
+            if added.recordDepsState() then addSub(added)
+            else CompareResult.fail(this)
           case _ =>
       result
 
     override def toString = s"Mapped$id($cv, elems = $elems)"
   end Mapped
 
-  class BiMapped private[CaptureSet] (cv: Var, bimap: BiTypeMap, initialElems: Refs) extends Var(initialElems):
+  class BiMapped private[CaptureSet] (cv: Var, bimap: BiTypeMap, initialElems: Refs)(using @constructorOnly ctx: Context) extends Var(initialElems):
     addSub(cv)
 
     override def addNewElems(newElems: Refs, origin: CaptureSet)(using Context, VarState): CompareResult =
@@ -302,7 +312,7 @@ object CaptureSet:
   end BiMapped
 
   /** A variable with elements given at any time as { x <- cv.elems | p(x) } */
-  class Filtered private[CaptureSet] (cv: Var, p: CaptureRef => Boolean)
+  class Filtered private[CaptureSet] (cv: Var, p: CaptureRef => Boolean)(using @constructorOnly ctx: Context)
   extends Var(cv.elems.filter(p)):
     addSub(cv)
 
@@ -370,6 +380,12 @@ object CaptureSet:
     override def putDeps(v: Var, deps: Deps) = false
     override def abort(): Unit = ()
 
+  @sharable
+  object UnrecordedState extends VarState:
+    override def putElems(v: Var, refs: Refs) = true
+    override def putDeps(v: Var, deps: Deps) = true
+    override def abort(): Unit = ()
+
   def varState(using state: VarState): VarState = state
 
   def ofClass(cinfo: ClassInfo, argTypes: List[Type])(using Context): CaptureSet =

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

@@ -615,14 +615,19 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           case _ =>
             isSubType(info1, info2)
 
-        tp1 match
-          case tp1: RefinedType
-          if ctx.phase == Phases.checkCapturesPhase
-              && defn.isFunctionOrPolyType(tp1)
-              && defn.isFunctionOrPolyType(tp2) =>
-            isSubInfo(tp1.refinedInfo, tp2.refinedInfo)
-          case _ =>
-            compareRefined
+        if ctx.phase == Phases.checkCapturesPhase then
+          if defn.isFunctionType(tp2) then
+            tp1.widenDealias match
+              case tp1: RefinedType =>
+                return isSubInfo(tp1.refinedInfo, tp2.refinedInfo)
+              case _ =>
+          else if tp2.parent.typeSymbol == defn.PolyFunctionClass then
+            tp1.member(nme.apply).info match
+              case info1: PolyType =>
+                return isSubInfo(info1, tp2.refinedInfo)
+              case _ =>
+
+        compareRefined
       case tp2: RecType =>
         def compareRec = tp1.safeDealias match {
           case tp1: RecType =>