Some infrastructure for making existentials Fresh instances

Author: odersky

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

@@ -26,7 +26,7 @@ import dotty.tools.dotc.util.SimpleIdentitySet
 object Fresh:
 
   /** The annotation of a Fresh instance */
-  case class Annot(hidden: CaptureSet.HiddenSet, binder: MethodType | NoType.type = NoType) extends Annotation:
+  case class Annot(hidden: CaptureSet.HiddenSet, binder: MethodType | NoType.type) extends Annotation:
     override def symbol(using Context) = defn.FreshCapabilityAnnot
     override def tree(using Context) = New(symbol.typeRef, Nil)
     override def derivedAnnotation(tree: Tree)(using Context): Annotation = this
@@ -45,11 +45,11 @@ object Fresh:
         case _ => this
   end Annot
 
-  /** Extractor methods for "fresh" capabilities */
+  /** Constructor and extractor methods for "fresh" capabilities */
   def apply(owner: Symbol, initialHidden: Refs = emptyRefs)(using Context): CaptureRef =
     if ccConfig.useSepChecks then
       val hiddenSet = CaptureSet.HiddenSet(owner, initialHidden)
-      val res = AnnotatedType(defn.captureRoot.termRef, Annot(hiddenSet))
+      val res = AnnotatedType(defn.captureRoot.termRef, Annot(hiddenSet, NoType))
       hiddenSet.owningCap = res
       //assert(hiddenSet.id != 3)
       res
@@ -63,9 +63,16 @@ object Fresh:
     apply(owner, ownerToHidden(owner, reach = false))
 
   def unapply(tp: AnnotatedType): Option[CaptureSet.HiddenSet] = tp.annot match
-    case Annot(hidden, _) => Some(hidden)
+    case Annot(hidden, binder) if !binder.exists => Some(hidden)
     case _ => None
 
+  /** Create an existential */
+  def existential(binder: MethodType)(using Context): AnnotatedType =
+    val hiddenSet = CaptureSet.HiddenSet(NoSymbol, emptyRefs)
+    val res = AnnotatedType(defn.captureRoot.termRef, Annot(hiddenSet, binder))
+    hiddenSet.owningCap = res
+    res
+
   /** The initial elements (either 0 or 1) of a hidden set created for given `owner`.
    *  If owner `x` is a trackable this is `x*` if reach` is true, or `x` otherwise.
    */

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

@@ -390,6 +390,18 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           case _ =>
         tp
 
+      /** Map references to capability classes C to C^,
+       *  normalize captures and map to dependent functions.
+       */
+      def defaultApply(t: Type) =
+        if t.derivesFromCapability
+          && !t.isSingleton
+          && t.typeSymbol != defn.Caps_Exists
+          && (!sym.isConstructor || (t ne tp.finalResultType))
+            // Don't add ^ to result types of class constructors deriving from Capability
+        then CapturingType(t, defn.universalCSImpliedByCapability, boxed = false)
+        else normalizeCaptures(normalizeFunctions(mapFollowingAliases(t), t))
+
       def innerApply(t: Type) =
         t match
           case t @ CapturingType(parent, refs) =>
@@ -414,15 +426,16 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               t.derivedAnnotatedType(parent1, ann)
           case throwsAlias(res, exc) =>
             this(expandThrowsAlias(res, exc, Nil))
+          case t @ AppliedType(tycon, args)
+          if defn.isNonRefinedFunction(tp)
+              && !defn.isFunctionSymbol(tp.typeSymbol) && (tp.dealias ne tp) =>
+            // Expand arguments of aliases of function types before proceeding with dealias.
+            // This is necessary to bind existentialFresh instances to the right method binder.
+            val args1 = atVariance(-variance):
+              args.map(this)
+            defaultApply(t.derivedAppliedType(tycon, args1))
           case t =>
-            // Map references to capability classes C to C^
-            if t.derivesFromCapability
-              && !t.isSingleton
-              && t.typeSymbol != defn.Caps_Exists
-              && (!sym.isConstructor || (t ne tp.finalResultType))
-                // Don't add ^ to result types of class constructors deriving from Capability
-            then CapturingType(t, defn.universalCSImpliedByCapability, boxed = false)
-            else normalizeCaptures(normalizeFunctions(mapFollowingAliases(t), t))
+            defaultApply(t)
     end toCapturing
 
     val tp1 = toCapturing(tp)

tests/neg-custom-args/captures/i19330.check

@@ -7,7 +7,7 @@
 22 |  val bad: bar.T = foo(bar) // error
    |                   ^^^^^^^^
    |                   Found:    () => Logger^
-   |                   Required: () ->{fresh} (ex$7: caps.Exists) -> Logger^{ex$7}
+   |                   Required: () ->{fresh} Logger^{fresh}
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/i19330.scala:16:14 ------------------------------------------------------------