Fixes to maps in Setup

 - Drop ToResultInResults
 - Move its functionality to separate methods in Setup
 - Implement dealias suppression logic for capset arguments.
   This is needed to be able to express referring with `fresh` to enclosing method types
   that don't immediately have the type containing the `fresh` as their result type.

# Conflicts:
#	tests/neg/i20481.check

Author: odersky

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

@@ -23,22 +23,23 @@ class CCState:
 
   // ------ BiTypeMap adjustment -----------------------
 
-  private var myMapFutureElems = true
+  private var myMapVars = true
 
-  /** When mapping a capture set with a BiTypeMap, should we create a BiMapped set
+  /** When mapping a capture set variable 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.
+   *  are back-propagated? Or should we return the capture set as is? 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 cases where this shows: pos-customargs/captures/lists.scala, method m2c, and
+   *  pos-customargs/captures/infer-exists.scala,
    */
-  def mapFutureElems(using Context) = myMapFutureElems
+  def mapVars(using Context) = myMapVars
 
-  /** Don't map future elements in this `op` */
-  inline def withoutMappedFutureElems[T](op: => T)(using Context): T =
-    val saved = mapFutureElems
-    myMapFutureElems = false
-    try op finally myMapFutureElems = saved
+  /** Don't map capset variables with BiTypeMaps during this `op` */
+  inline def withNoVarsMapped[T](op: => T)(using Context): T =
+    val saved = mapVars
+    myMapVars = false
+    try op finally myMapVars = saved
 
   // ------ Iteration count of capture checking run
 

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

@@ -1058,16 +1058,14 @@ object Capabilities:
         case t @ CapturingType(_, _) =>
           mapOver(t)
         case t @ AnnotatedType(parent, ann: RetainingAnnotation)
-        if ann.isStrict && ann.toCaptureSet.containsGlobalCapDerivs =>
+        if ann.isStrict && ann.toCaptureSet.elems.exists(_.core.isInstanceOf[GlobalCap]) =>
           // Applying `this` can cause infinite recursion in some cases during printing.
           // scalac -Xprint:all tests/pos/i23885/S_1.scala tests/pos/i23885/S_2.scala
           mapOver(CapturingType(this(parent), ann.toCaptureSet))
         case t @ AnnotatedType(parent, ann) =>
           t.derivedAnnotatedType(this(parent), ann)
         case t @ defn.RefinedFunctionOf(mt) =>
-          if ccConfig.newScheme
-          then t.derivedRefinedType(refinedInfo = mapOver(mt))
-          else t
+          t.derivedRefinedType(refinedInfo = mapOver(mt))
         case _ =>
           mapFollowingAliases(t)
 
@@ -1100,11 +1098,11 @@ object Capabilities:
   /** Maps caps.any to LocalCap instances. GlobalToLocalCap is a BiTypeMap since we don't want to
    *  freeze a set when it is mapped. On the other hand, we do not want LocalCap
    *  values to flow back to caps.any since that would fail disallowRootCapability
-   *  tests elsewhere. We therefore use `withoutMappedFutureElems` to prevent
+   *  tests elsewhere. We therefore use `withNoVarsMapped` to prevent
    *  the map being installed for future use.
    */
   def globalCapToLocal(tp: Type, origin: Origin)(using Context): Type =
-    ccState.withoutMappedFutureElems:
+    ccState.withNoVarsMapped:
       GlobalCapToLocal(origin)(tp)
 
   /** Maps all LocalCap instances to caps.any */
@@ -1220,36 +1218,26 @@ object Capabilities:
 
   class ToResult(localResType: Type, mt: MethodicType, sym: Symbol, fail: Message => Unit)(using Context) extends CapMap:
 
-    def apply(t: Type) = t match
-      case defn.FunctionNOf(args, res, contextual) if t.typeSymbol.name.isImpureFunction && !(ccConfig.newScheme) =>
-        if variance > 0 then
-          super.mapOver:
-            defn.FunctionNOf(args, res, contextual)
-              .capturing(ResultCap(mt).singletonCaptureSet)
-        else mapOver(t)
-      case _ =>
-        mapOver(t)
+    def apply(t: Type) = mapOver(t)
 
     override def mapCapability(c: Capability, deep: Boolean) = c match
-      case c: (LocalCap | GlobalCap) =>
+      case c: LocalCap =>
         if variance > 0 then
-          c match
-            case c: LocalCap =>
-              if sym.isAnonymousFunction && c.classifier.derivesFrom(defn.Caps_Unscoped) then
-                c
-              else if sym.exists && !c.ccOwner.isContainedIn(sym.skipAnonymousOwners) then
-                //println(i"not mapping $c with ${c.ccOwner} in $sym")
-                c
-              else
-                ResultCap(mt).setOrigin(c)
-            case _ =>
-              if c == GlobalFresh || !(ccConfig.newScheme) then ResultCap(mt) else c
+          if sym.isAnonymousFunction && c.classifier.derivesFrom(defn.Caps_Unscoped) then
+            c
+          else if sym.exists && !c.ccOwner.isContainedIn(sym.skipAnonymousOwners) then
+            //println(i"not mapping $c with ${c.ccOwner} in $sym")
+            c
+          else
+            ResultCap(mt).setOrigin(c)
         else
           if variance == 0 then
             fail(em"""$localResType captures the root capability `any` in invariant position.
-                      |This capability cannot be converted to an existential in the result type of a function.""")
-          // we accept variance < 0, and leave the `any` as it is
+                     |This capability cannot be converted to a fresh capability in the result type of a function.""")
+          // we accept variance < 0, and leave the `any` as it is          c
           c
+      case GlobalFresh if variance > 0 =>
+        ResultCap(mt) // if variance <= 0 we leave the fresh to be flagged later
       case _ =>
         super.mapCapability(c, deep)
 
@@ -1282,54 +1270,4 @@ object Capabilities:
    */
   def toResult(tp: Type, mt: MethodicType, sym: Symbol, fail: Message => Unit)(using Context): Type =
     ToResult(tp, mt, sym, fail)(tp)
-
-  /** Map global roots in function results to result roots. Also,
-   *  map roots in the types of def methods that are parameterless
-   *  or have only type parameters.
-   */
-  def toResultInResults(sym: Symbol, fail: Message => Unit, keepAliases: Boolean = false)(tp: Type)(using Context): Type =
-    val m = new TypeMap with FollowAliasesMap:
-      def apply(t: Type): Type = t match
-        case rt @ defn.RefinedFunctionOf(mt) =>
-          rt.derivedRefinedType(refinedInfo =
-            if rt.isInstanceOf[InferredRefinedType]
-            then mapOver(mt) // Don't map to Result for dependent function types created from non-dependent ones in inferred types
-            else apply(mt))
-        case t @ AppliedType(tycon, args)
-        if defn.isNonRefinedFunction(t) && args.last.containsFresh && ccConfig.newScheme =>
-          // Convert to dependent function so that we have a binder for `fresh` in result type.
-          apply(
-            depFun(args.init, args.last,
-              isContextual = defn.isContextFunctionClass(tycon.classSymbol)))
-        case t: MethodType if variance > 0 && t.marksExistentialScope =>
-          val t1 = mapOver(t).asInstanceOf[MethodType]
-          t1.derivedLambdaType(resType = toResult(t1.resType, t1, sym, fail))
-        case CapturingType(parent, refs) =>
-          t.derivedCapturingType(this(parent), refs)
-        case t: (LazyRef | TypeVar) =>
-          mapConserveSuper(t)
-        case _ =>
-          try
-            if keepAliases then mapOver(t)
-            else mapFollowingAliases(t)
-          catch case ex: AssertionError =>
-            println(i"error while mapping $t")
-            throw ex
-    m(tp) match
-      case tp1: ExprType if sym.is(Method, butNot = Accessor) =>
-        // Map the result of parameterless `def` methods.
-        tp1.derivedExprType(toResult(tp1.resType, tp1, sym, fail))
-      case tp1: PolyType if !tp1.resType.isInstanceOf[MethodicType] =>
-        // Map also the result type of method with only type parameters.
-        // This way, the `^` in the following method will be mapped to a `ResultCap`:
-        // ```
-        // object Buffer:
-        //   def empty[T]: Buffer[T]^
-        // ```
-        // This is more desirable than interpreting `^` as a `^{any}` at the level of `Buffer.empty`
-        // in most cases.
-        tp1.derivedLambdaType(resType = toResult(tp1.resType, tp1, sym, fail))
-      case tp1 => tp1
-  end toResultInResults
-
 end Capabilities

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

@@ -105,7 +105,12 @@ extension (tp: Type)
 
   /** A list of capabilities of a retained set. */
   def retainedElements(using Context): List[Capability] =
-    retainedElementsRaw.map(_.toCapability)
+    retainedElementsRaw.flatMap: elem =>
+      elem match
+        case CapturingType(parent, refs) if parent.derivesFrom(defn.Caps_CapSet) =>
+          refs.elems.toList
+        case _ =>
+          elem.toCapability :: Nil
 
   /** Is this type a Capability that can be tracked?
    *  This is true for
@@ -456,20 +461,31 @@ extension (tp: Type)
       tp
   end withReachCaptures
 
-  /** Does this type contain no-flip covariant occurrences of `any`? */
-  def containsCap(using Context): Boolean =
-    val acc = new TypeAccumulator[Boolean]:
+  private def containsGlobal(c: GlobalCap, directly: Boolean)(using Context): Boolean =
+    val search = new TypeAccumulator[Boolean]:
       def apply(x: Boolean, t: Type) =
-        x
-        || variance > 0 && t.dealiasKeepAnnots.match
-          case t @ CapturingType(p, cs) if cs.containsGlobalCapDerivs =>
+        if x then true
+        else if variance <= 0 then false
+        else if directly && defn.isFunctionSymbol(t.typeSymbol) then false
+        else t match
+          case CapturingType(_, refs) if refs.elems.exists(_.core == c) =>
             true
           case t @ AnnotatedType(parent, ann) =>
             // Don't traverse annotations, which includes capture sets
             this(x, parent)
           case _ =>
             foldOver(x, t)
-    acc(false, tp)
+    search(false, tp)
+
+  /** Does this type contain no-flip covariant occurrences of `any`? */
+  def containsGlobalAny(using Context): Boolean =
+    containsGlobal(GlobalAny, directly = false)
+
+  /** Does `tp` contain contain no-flip covariant occurrences of `fresh` directly,
+   *  which are not in the result of some function type?
+   */
+  def containsGlobalFreshDirectly(using Context): Boolean =
+    containsGlobal(GlobalFresh, directly = true)
 
   def refinedOverride(name: Name, rinfo: Type)(using Context): Type =
     RefinedType.precise(tp, name, rinfo)
@@ -502,20 +518,7 @@ extension (tp: Type)
     if tp.isArrayUnderStrictMut then defn.Caps_Unscoped
     else tp.classSymbols.map(_.classifier).foldLeft(defn.AnyClass)(leastClassifier)
 
-  /** Does `tp` contain a `fresh` directly, which is not in the result of some function type?
-   */
-  def containsFresh(using Context): Boolean =
-    val search = new TypeAccumulator[Boolean]:
-      def apply(x: Boolean, tp: Type): Boolean =
-        if x then true
-        else if defn.isFunctionType(tp) then false
-        else tp match
-          case CapturingType(parent, refs) =>
-            refs.elems.exists(_.core == GlobalFresh) || apply(x, parent)
-          case _ => foldOver(x, tp)
-    search(false, tp)
-
-extension (tp: MethodType)
+extension (tp: MethodOrPoly)
   /** A method marks an existential scope unless it is the prefix of a curried method */
   def marksExistentialScope(using Context): Boolean =
     !tp.resType.isInstanceOf[MethodOrPoly]

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

@@ -143,9 +143,6 @@ sealed abstract class CaptureSet extends Showable:
         case _: LocalCap => true
         case _ => false
 
-  final def containsGlobalCapDerivs(using Context) =
-    elems.exists(_.core.isInstanceOf[GlobalCap])
-
   final def isReadOnly(using Context): Boolean =
     elems.forall(_.isReadOnly)
 
@@ -392,9 +389,13 @@ sealed abstract class CaptureSet extends Showable:
   /** Capture set obtained by applying `tm` to all elements of the current capture set
    *  and joining the results. If the current capture set is a variable we handle this as
    *  follows:
-   *    - If the map is a BiTypeMap, the same transformation is applied to all
-   *      future additions of new elements. We try to fuse with previous maps to
-   *      avoid long paths of BiTypeMapped sets.
+   *    - If the map is a BiTypeMap, and CCState.mapVars is true,
+   *      the same transformation is applied to all future additions of new elements.
+   *      We try to fuse with previous maps to avoid long paths of BiTypeMapped sets.
+   *    - If the map is a BiTypeMap, and CCState.mapVars is false,
+   *      we return the original capture set. In this case any elements that are
+   *      already in the set must be invariant under the mapping. This mode is
+   *      necessary for bootstrap when we create capset variables the first time.
    *    - If the map is some other map that maps the current set of elements
    *      to itself, return the current var. We implicitly assume that the map
    *      will also map any elements added in the future to themselves. This assumption
@@ -410,7 +411,7 @@ sealed abstract class CaptureSet extends Showable:
         if isConst then
           if mappedElems == elems then this
           else Const(mappedElems)
-        else if ccState.mapFutureElems then
+        else if ccState.mapVars then
           def unfused =
             if debugVars then
               try BiMapped(asVar, tm, mappedElems)
@@ -423,7 +424,9 @@ sealed abstract class CaptureSet extends Showable:
               case Some(fused: BiTypeMap) => BiMapped(self.source, fused, mappedElems)
               case _ => unfused
             case _ => unfused
-        else this
+        else
+          assert(mappedElems == elems)
+          this
       case tm: IdentityCaptRefMap =>
         this
       case tm: AvoidMap if this.isInstanceOf[HiddenSet] =>
@@ -928,7 +931,7 @@ object CaptureSet:
         this
       else if isUniversal || computingApprox then
         universal
-      else if containsGlobalCapDerivs && isReadOnly then
+      else if elems.exists(_.core == GlobalAny) && isReadOnly then
         shared
       else
         computingApprox = true
@@ -1091,8 +1094,8 @@ object CaptureSet:
 
     // ----------- Longest path recording -------------------------
 
-    /** Summarize for set displaying in a path */
-    def summarize: String = getClass.toString
+    /** Summarize set when displaying a propagation path */
+    def summarize(using Context): String = getClass.toString
 
     /** The length of the path of DerivedVars ending in this set */
     def pathLength: Int = source match
@@ -1132,7 +1135,6 @@ object CaptureSet:
         try
           reporting.trace(i"prop backwards $elem from $this # $id to $source # ${source.id} via $summarize"):
             source.tryInclude(bimap.inverse.mapCapability(elem), this)
-              .showing(i"propagating new elem $elem backward from $this/$id to $source = $result", captDebug)
         catch case ex: AssertionError =>
           println(i"fail while prop backwards tryInclude $elem of ${elem.getClass} from $this # $id / ${this.summarize} to $source # ${source.id}")
           throw ex
@@ -1151,7 +1153,7 @@ object CaptureSet:
 
     override def isMaybeSet: Boolean = bimap.isInstanceOf[MaybeMap]
     override def toString = s"BiMapped$id($source, elems = $elems)"
-    override def summarize = bimap.getClass.toString
+    override def summarize(using Context) = bimap.summarize
     override def repr(using Context): Name = source.repr
   end BiMapped
 

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

@@ -880,7 +880,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         // See [[MethodTypeCompanion.adaptParamInfo]].
         capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
         markFree(argType.deepCaptureSet, arg)
-      if formal.containsCap then
+      if formal.containsGlobalAny then
         sepCheckFormals(arg) = instantiatedFormal
       argType