Adapt types according to read-only status (#23332)

Extend type adaptation to read-only status.

Two big improvements:

- we also adapt if the target type is a mutable type with a read-only
capture set. So the following compiles:
   ```scala
   class Ref extends Mutable { ... }
   val x: Ref^{cap.rd} = Ref()
   ```
 - we also adapt deeply inside a type. So the following compiles:

   ```scala
    val refs = List(Ref(), Ref())
    val rdrs: List[Ref^{cap.rd}] = refs
   ```
We even try to track arguments through base types, so the following also
compiles:
   ```scala
   val rdrs2: Seq[Ref^{cap.rd}] = refs
   ```
But there are some limits, correlating actual and expected type through
base types and as-seen-from is hard.

In the end I had to abandon the original idea to roll everyhting into
subtyping. I got the basics to work, but the problem then was that we
use deep capture sets in separation checking, and those were not
adapted. To do this, we'd have to somehow figure out what a dcs relative
to an expected type is. This looks deeply non-trivial, and would
probably in the end come down to techniques similar to the adaptation in
this PR. So the benefit of also adding and inferring qualifiers to
capture sets are not clear.

EDIT: We do need qualifiers for soundness as @Linyxus example below
shows. It's now in `ro-mut-conformance.scala`.
So the adaptation commit has been rebased on the mutability qualifiers
branch.

Author: odersky

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

@@ -70,14 +70,17 @@ class CCState:
 
   // ------ Iteration count of capture checking run
 
-  private var iterCount = 1
+  private var iterCount = 0
 
   def iterationId = iterCount
 
   def nextIteration[T](op: => T): T =
     iterCount += 1
     try op finally iterCount -= 1
 
+  def start(): Unit =
+    iterCount = 1
+
   // ------ Global counters -----------------------
 
   /** Next CaptureSet.Var id */

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

@@ -330,6 +330,12 @@ object Capabilities:
     final def isExclusive(using Context): Boolean =
       !isReadOnly && (isTerminalCapability || captureSetOfInfo.isExclusive)
 
+    /** Similar to isExlusive, but also includes capabilties with capture
+     *  set variables in their info whose status is still open.
+     */
+    final def maybeExclusive(using Context): Boolean =
+      !isReadOnly && (isTerminalCapability || captureSetOfInfo.maybeExclusive)
+
     final def isWellformed(using Context): Boolean = this match
       case self: CoreCapability => self.isTrackableRef
       case _ => true

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

@@ -22,11 +22,18 @@ private val Captures: Key[CaptureSet] = Key()
 def isCaptureChecking(using Context): Boolean =
   ctx.phaseId == Phases.checkCapturesPhase.id
 
-/** Are we at checkCaptures or Setup phase? */
+/** Are we in the CheckCaptures or Setup phase? */
 def isCaptureCheckingOrSetup(using Context): Boolean =
-  val ccId = Phases.checkCapturesPhase.id
-  val ctxId = ctx.phaseId
-  ctxId == ccId || ctxId == ccId - 1
+  val ccPhase = Phases.checkCapturesPhase
+  ccPhase.exists
+  && {
+    val ccId = ccPhase.id
+    val ctxId = ctx.phaseId
+    ctxId == ccId
+    || ctxId == ccId - 1 && ccState.iterationId > 0
+      // Note: just checking phase id is not enough since Setup would
+      // also be the phase after pattern matcher.
+  }
 
 /** A dependent function type with given arguments and result type
  *  TODO Move somewhere else where we treat all function type related ops together.