CC: Drop idempotent type maps

compiler/src/dotty/tools/dotc/Run.scala

@@ -42,7 +42,8 @@ import dotty.tools.dotc.util.chaining.*
 import java.util.{Timer, TimerTask}
 
 /** A compiler run. Exports various methods to compile source files */
-class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
+class Run(comp: Compiler, ictx: Context)
+extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo {
 
   /** Default timeout to stop looking for further implicit suggestions, in ms.
    *  This is usually for the first import suggestion; subsequent suggestions
@@ -519,6 +520,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   /** Print summary of warnings and errors encountered */
   def printSummary(): Unit = {
     printMaxConstraint()
+    printMaxPath()
     val r = runContext.reporter
     if !r.errorsReported then
       profile.printSummary()
@@ -529,6 +531,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   override def reset(): Unit = {
     super[ImplicitRunInfo].reset()
     super[ConstraintRunInfo].reset()
+    super[CaptureRunInfo].reset()
     myCtx = null
     myUnits = Nil
     myUnitsCached = Nil

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -56,7 +56,7 @@ class TreeTypeMap(
   /** Replace occurrences of `This(oldOwner)` in some prefix of a type
    *  by the corresponding `This(newOwner)`.
    */
-  private val mapOwnerThis = new TypeMap with cc.CaptureSet.IdempotentCaptRefMap {
+  private val mapOwnerThis = new TypeMap {
     private def mapPrefix(from: List[Symbol], to: List[Symbol], tp: Type): Type = from match {
       case Nil => tp
       case (cls: ClassSymbol) :: from1 => mapPrefix(from1, to.tail, tp.substThis(cls, to.head.thisType))

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

@@ -26,14 +26,14 @@ val PrintFresh: Key[Unit] = Key()
 
 object ccConfig:
 
-  /** If true, allow mapping capture set variables under captureChecking with maps that are neither
-   *  bijective nor idempotent. We currently do now know how to do this correctly in all
-   *  cases, though.
+  /** If enabled, use a special path in recheckClosure for closures
+   *  to compare the result tpt of the anonymous functon with the expected
+   *  result type. This can narrow the scope of error messages.
    */
-  inline val allowUnsoundMaps = false
+  inline val preTypeClosureResults = false
 
-  /** If enabled, use a special path in recheckClosure for closures
-   *  that are eta expansions. This can improve some error messages.
+  /** If this and `preTypeClosureResults` are both enabled, disable `preTypeClosureResults`
+   *  for eta expansions. This can improve some error messages.
    */
   inline val handleEtaExpansionsSpecially = true
 
@@ -43,13 +43,35 @@ object ccConfig:
    */
   inline val deferredReaches = false
 
+  /** Check that if a type map (which is not a BiTypeMap) maps initial capture
+   *  set variable elements to themselves it will not map any elements added in
+   *  the future to something else. That is, we can safely use a capture set
+   *  variable itself as the image under the map. By default this is off since it
+   *  is a bit expensive to check.
+   */
+  inline val checkSkippedMaps = false
+
+  /** Always repeat a capture checking run at least once if there are no errors
+   *  yet. Used for stress-testing the logic for when a new capture checking run needs
+   *  to be scheduled because a provisionally solved capture set was later extended.
+   *  So far this happens only in very few tests. With the flag on, the logic is
+   *  tested for all tests except neg tests.
+   */
+  inline val alwaysRepeatRun = false
+
+  /** After capture checking, check that no capture set contains ParamRefs that are outside
+   *  its scope. This used to occur and was fixed by healTypeParam. It should no longer
+   *  occur now.
+   */
+  inline val postCheckCapturesets = false
+
   /** If true, turn on separation checking */
   def useSepChecks(using Context): Boolean =
     Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)
 
   /** Not used currently. Handy for trying out new features */
   def newScheme(using Context): Boolean =
-    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)
+    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.8`)
 
 end ccConfig
 
@@ -112,6 +134,13 @@ class CCState:
 
   private var capIsRoot: Boolean = false
 
+  /** If true, apply a BiTypeMap also to elements added to the set in the future
+   *  (and use its inverse when back-progating).
+   */
+  private var mapFutureElems = true
+
+  var iterCount = 1
+
 object CCState:
 
   opaque type Level = Int
@@ -168,9 +197,25 @@ object CCState:
       try op finally ccs.capIsRoot = saved
     else op
 
+  /** Don't map future elements in this `op` */
+  inline def withoutMappedFutureElems[T](op: => T)(using Context): T =
+    val ccs = ccState
+    val saved = ccs.mapFutureElems
+    ccs.mapFutureElems = false
+    try op finally ccs.mapFutureElems = saved
+
   /** Is `caps.cap` a root capability that is allowed to subsume other capabilities? */
   def capIsRoot(using Context): Boolean = ccState.capIsRoot
 
+  /** When mapping a capture set with a BiTypeMap, should we create a BiMapped set
+   *  so that future elements can also be mapped, and elements added to the BiMapped
+   *  are back-propagated? Turned off when creating capture set variables for the
+   *  first time, since we then do not want to change the binder to the original type
+   *  without capture sets when back propagating. Error case where this shows:
+   *  pos-customargs/captures/lists.scala, method m2c.
+   */
+  def mapFutureElems(using Context) = ccState.mapFutureElems
+
   /** The currently opened existential scopes */
   def openExistentialScopes(using Context): List[MethodType] = ccState.openExistentialScopes
 
@@ -251,7 +296,8 @@ extension (tp: Type)
     case tp: TypeRef =>
       tp.symbol.isType && tp.derivesFrom(defn.Caps_CapSet)
     case tp: TypeParamRef =>
-      tp.derivesFrom(defn.Caps_CapSet)
+      !tp.underlying.exists // might happen during construction of lambdas
+      || tp.derivesFrom(defn.Caps_CapSet)
     case root.Result(_) => true
     case AnnotatedType(parent, annot) =>
       defn.capabilityWrapperAnnots.contains(annot.symbol) && parent.isTrackableRef
@@ -322,8 +368,7 @@ extension (tp: Type)
   def boxed(using Context): Type = tp.dealias match
     case tp @ CapturingType(parent, refs) if !tp.isBoxed && !refs.isAlwaysEmpty =>
       tp.annot match
-        case ann: CaptureAnnotation =>
-          assert(!parent.derivesFrom(defn.Caps_CapSet))
+        case ann: CaptureAnnotation if !parent.derivesFrom(defn.Caps_CapSet) =>
           AnnotatedType(parent, ann.boxedAnnot)
         case ann => tp
     case tp: RealTypeBounds =>
@@ -335,7 +380,8 @@ extension (tp: Type)
    *  are of the form this.C but their pathroot is still this.C, not this.
    */
   final def pathRoot(using Context): Type = tp.dealias match
-    case tp1: NamedType if tp1.symbol.maybeOwner.isClass && !tp1.symbol.is(TypeParam) =>
+    case tp1: NamedType
+    if tp1.symbol.maybeOwner.isClass && tp1.symbol != defn.captureRoot && !tp1.symbol.is(TypeParam) =>
       tp1.prefix.pathRoot
     case tp1 => tp1
 

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

@@ -9,21 +9,30 @@ import typer.ErrorReporting.Addenda
 import util.common.alwaysTrue
 import scala.collection.mutable
 import CCState.*
-import Periods.NoRunId
+import Periods.{NoRunId, RunWidth}
 import compiletime.uninitialized
 import StdNames.nme
 import CaptureSet.VarState
 import Annotations.Annotation
 import config.Printers.capt
 
+object CaptureRef:
+  opaque type Validity = Int
+  def validId(runId: Int, iterId: Int): Validity =
+    runId + (iterId << RunWidth)
+  def currentId(using Context): Validity = validId(ctx.runId, ccState.iterCount)
+  val invalid: Validity = validId(NoRunId, 0)
+
 /** A trait for references in CaptureSets. These can be NamedTypes, ThisTypes or ParamRefs,
  *  as well as three kinds of AnnotatedTypes representing readOnly, reach, and maybe capabilities.
  *  If there are several annotations they come with an order:
  *  `*` first, `.rd` next, `?` last.
  */
 trait CaptureRef extends TypeProxy, ValueType:
+  import CaptureRef.*
+
   private var myCaptureSet: CaptureSet | Null = uninitialized
-  private var myCaptureSetRunId: Int = NoRunId
+  private var myCaptureSetValid: Validity = invalid
   private var mySingletonCaptureSet: CaptureSet.Const | Null = null
   private var myDerivedRefs: List[AnnotatedType] = Nil
 
@@ -130,20 +139,24 @@ trait CaptureRef extends TypeProxy, ValueType:
 
   /** The capture set of the type underlying this reference */
   final def captureSetOfInfo(using Context): CaptureSet =
-    if ctx.runId == myCaptureSetRunId then myCaptureSet.nn
+    if myCaptureSetValid == currentId then myCaptureSet.nn
     else if myCaptureSet.asInstanceOf[AnyRef] eq CaptureSet.Pending then CaptureSet.empty
     else
       myCaptureSet = CaptureSet.Pending
       val computed = CaptureSet.ofInfo(this)
-      if !isCaptureChecking || ctx.mode.is(Mode.IgnoreCaptures) || underlying.isProvisional then
+      if !isCaptureChecking
+          || ctx.mode.is(Mode.IgnoreCaptures)
+          || !underlying.exists
+          || underlying.isProvisional
+      then
         myCaptureSet = null
       else
         myCaptureSet = computed
-        myCaptureSetRunId = ctx.runId
+        myCaptureSetValid = currentId
       computed
 
   final def invalidateCaches() =
-    myCaptureSetRunId = NoRunId
+    myCaptureSetValid = invalid
 
   /**  x subsumes x
    *   x =:= y       ==>  x subsumes y
@@ -252,12 +265,18 @@ trait CaptureRef extends TypeProxy, ValueType:
     || this.match
       case root.Fresh(hidden) =>
         vs.ifNotSeen(this)(hidden.elems.exists(_.subsumes(y)))
-        || !y.stripReadOnly.isCap && !yIsExistential && canAddHidden && vs.addHidden(hidden, y)
+        || !y.stripReadOnly.isCap
+            && !yIsExistential
+            && !y.isInstanceOf[TermParamRef]
+            && canAddHidden
+            && vs.addHidden(hidden, y)
       case x @ root.Result(binder) =>
-        if y.derivesFromSharedCapability then true
-        else
+        val result = y match
+          case y @ root.Result(_) => vs.unify(x, y)
+          case _ => y.derivesFromSharedCapability
+        if !result then
           ccState.addNote(CaptureSet.ExistentialSubsumesFailure(x, y))
-          false
+        result
       case _ =>
         y match
           case ReadOnlyCapability(y1) => this.stripReadOnly.maxSubsumes(y1, canAddHidden)

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

@@ -0,0 +1,25 @@
+package dotty.tools.dotc
+package cc
+
+import core.Contexts.{Context, ctx}
+import config.Printers.capt
+
+trait CaptureRunInfo:
+  self: Run =>
+  private var maxSize = 0
+  private var maxPath: List[CaptureSet.DerivedVar] = Nil
+
+  def recordPath(size: Int, path: => List[CaptureSet.DerivedVar]): Unit =
+    if size > maxSize then
+      maxSize = size
+      maxPath = path
+
+  def printMaxPath()(using Context): Unit =
+    if maxSize > 0 then
+      println(s"max derived capture set path length: $maxSize")
+      println(s"max derived capture set path: ${maxPath.map(_.summarize).reverse}")
+
+  protected def reset(): Unit =
+    maxSize = 0
+    maxPath = Nil
+end CaptureRunInfo