Expand cap arguments of function aliases before de-aliasing

This is needed to that we can express functions where the result existential
scopes over a method type before the directly enclosing one. Example, from
`cc-existential-conformance.scala`:

  type Fun[X] = A -> X
  A -> A -> B^            prints as   A -> A -> B^
  A -> Fun[B^]            prints as   A -> A -> B^{outer_cap}

That is, the B^ is tied to the outer function.

Author: odersky

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

@@ -101,7 +101,7 @@ class CCState:
   private var curLevel: Level = outermostLevel
   private val symLevel: mutable.Map[Symbol, Int] = mutable.Map()
 
-  private var openedFreshBinders: List[MethodType] = Nil
+  private var openExistentialScopes: List[MethodType] = Nil
 
 object CCState:
 
@@ -134,20 +134,21 @@ object CCState:
     if !p then ccs.curLevel = ccs.curLevel.nextInner
     try op finally ccs.curLevel = saved
 
-  /** If we are currently in capture checking or setup, perform `op` assuming
-   *  a fresh enclosing binder `mt`, otherwise perform `op` directly.
+  /** If we are currently in capture checking or setup, and `mt` is a method
+   *  type that is not a prefix of a curried method, perform `op` assuming
+   *  a fresh enclosing existential scope `mt`, otherwise perform `op` directly.
    */
-  inline def inOpenedFreshBinder[T](mt: MethodType)(op: => T)(using Context): T =
+  inline def inNewExistentialScope[T](mt: MethodType)(op: => T)(using Context): T =
     if isCaptureCheckingOrSetup then
       val ccs = ccState
-      val saved = ccs.openedFreshBinders
-      if mt.isFreshBinder then ccs.openedFreshBinders = mt :: ccs.openedFreshBinders
-      try op finally ccs.openedFreshBinders = saved
+      val saved = ccs.openExistentialScopes
+      if mt.marksExistentialScope then ccs.openExistentialScopes = mt :: ccs.openExistentialScopes
+      try op finally ccs.openExistentialScopes = saved
     else
       op
 
-  /** The currently opened fresh binders */
-  def openedFreshBinders(using Context): List[MethodType] = ccState.openedFreshBinders
+  /** The currently opened existential scopes */
+  def openExistentialScopes(using Context): List[MethodType] = ccState.openExistentialScopes
 
   extension (x: Level)
     def isDefined: Boolean = x >= 0
@@ -590,14 +591,19 @@ extension (tp: Type)
     case tp: ThisType => tp.cls.ccLevel.nextInner
     case _ => undefinedLevel
 
+  /** Is this a method or function that has `other` as its direct or indirect result
+   *  type?
+   */
   def hasSuffix(other: MethodType)(using Context): Boolean =
     (tp eq other) || tp.match
-      case tp: MethodOrPoly => tp.resType.hasSuffix(other)
+      case defn.RefinedFunctionOf(mt) => mt.hasSuffix(other)
+      case mt: MethodType => mt.resType.hasSuffix(other)
       case _ => false
 
-  def isFreshBinder(using Context): Boolean = tp match
-    case tp: MethodType => !tp.resType.isInstanceOf[MethodOrPoly]
-    case _ => false
+extension (tp: MethodType)
+  /** A method marks an existential scope unless it is the prefix of a curried method */
+  def marksExistentialScope(using Context): Boolean =
+    !tp.resType.isInstanceOf[MethodOrPoly]
 
 extension (cls: ClassSymbol)
 

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

@@ -14,6 +14,7 @@ import compiletime.uninitialized
 import StdNames.nme
 import CaptureSet.VarState
 import Annotations.Annotation
+import config.Printers.capt
 
 /** 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.
@@ -259,6 +260,7 @@ trait CaptureRef extends TypeProxy, ValueType:
       case Existential.Vble(binder) =>
         y.stripReadOnly match
           case Existential.Vble(binder1) => binder1.hasSuffix(binder)
+            .showing(i"cmp existential $binder maxSubsumes $binder1 = $result", capt)
           case _ => true
       case _ =>
         this.isCap && canAddHidden && vs != VarState.HardSeparate

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

@@ -572,7 +572,7 @@ object CaptureSet:
       else elem match
         case elem @ Existential.Vble(mt) =>
           !noUniversal
-          && !CCState.openedFreshBinders.contains(elem)
+          && !CCState.openExistentialScopes.contains(elem)
             // Opened existentials on the left cannot be added to nested capture sets on the right
             // of a comparison. Test case is open-existential.scala.
         case elem: TermRef if level.isDefined =>

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

@@ -165,7 +165,10 @@ object CheckCaptures:
     val check = new TypeTraverser:
 
       private val seen = new EqHashSet[TypeRef]
-      var openFreshBinders: List[MethodType] = Nil
+
+      // We keep track of open existential scopes here so that we can set these scopes
+      // in ccState when printing a part of the offending type.
+      var openExistentialScopes: List[MethodType] = Nil
 
       def traverse(t: Type) =
         t.dealiasKeepAnnots match
@@ -184,32 +187,32 @@ object CheckCaptures:
             ()
           case CapturingType(parent, refs) =>
             if variance >= 0 then
-              val openBinders = openFreshBinders
+              val openScopes = openExistentialScopes
               refs.disallowRootCapability: () =>
                 def part =
                   if t eq tp then ""
                   else
-                    // Show in context of all enclosing traversed fresh binders.
+                    // Show in context of all enclosing traversed existential scopes.
                     def showInOpenedFreshBinders(mts: List[MethodType]): String = mts match
                       case Nil => i"the part $t of "
                       case mt :: mts1 =>
-                        CCState.inOpenedFreshBinder(mt):
+                        CCState.inNewExistentialScope(mt):
                           showInOpenedFreshBinders(mts1)
-                    showInOpenedFreshBinders(openBinders.reverse)
+                    showInOpenedFreshBinders(openScopes.reverse)
                 report.error(
                   em"""$what cannot $have $tp since
                       |${part}that type captures the root capability `cap`.$addendum""",
                   pos)
             traverse(parent)
           case defn.RefinedFunctionOf(mt) =>
             traverse(mt)
-          case t: MethodType if t.isFreshBinder =>
+          case t: MethodType if t.marksExistentialScope =>
             atVariance(-variance):
               t.paramInfos.foreach(traverse)
-            val saved = openFreshBinders
-            openFreshBinders = t :: openFreshBinders
+            val saved = openExistentialScopes
+            openExistentialScopes = t :: openExistentialScopes
             try traverse(t.resType)
-            finally openFreshBinders = saved
+            finally openExistentialScopes = saved
           case t =>
             traverseChildren(t)
     if ccConfig.useSealed then check.traverse(tp)

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

@@ -238,7 +238,7 @@ object Existential:
         case t: MethodType =>
           // skip parameters
           val saved = localBinders
-          if t.isFreshBinder then localBinders = localBinders + t
+          if t.marksExistentialScope then localBinders = localBinders + t
           try t.derivedLambdaType(resType = this(t.resType))
           finally localBinders = saved
         case t: PolyType =>
@@ -318,21 +318,21 @@ object Existential:
   end mapCap
 
   /** Map `cap` in function results to fresh existentials */
-  def mapCapInResults(fail: Message => Unit)(using Context): TypeMap = new TypeMap with FollowAliasesMap:
+  def mapCapInResults(fail: Message => Unit, keepAliases: Boolean = false)(using Context): TypeMap = new TypeMap with FollowAliasesMap:
     def apply(t: Type): Type = t match
       case defn.RefinedFunctionOf(mt) =>
         val mt1 = apply(mt)
         if mt1 ne mt then mt1.toFunctionType(alwaysDependent = true)
         else t
-      case t: MethodType if variance > 0 && t.isFreshBinder =>
+      case t: MethodType if variance > 0 && t.marksExistentialScope =>
         val t1 = mapOver(t).asInstanceOf[MethodType]
         t1.derivedLambdaType(resType = mapCap(t1.resType, t1, fail))
       case CapturingType(parent, refs) =>
         t.derivedCapturingType(this(parent), refs)
       case t: (LazyRef | TypeVar) =>
         mapConserveSuper(t)
       case _ =>
-        mapFollowingAliases(t)
+        if keepAliases then mapOver(t) else mapFollowingAliases(t)
   end mapCapInResults
 
 end Existential

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

@@ -201,17 +201,19 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     /** Map parametric functions with results that have a capture set somewhere
      *  to dependent functions.
      */
-    protected def normalizeFunctions(tp: Type, original: Type)(using Context): Type = tp match
+    protected def normalizeFunctions(tp: Type, original: Type, expandAlways: Boolean = false)(using Context): Type =
+      tp match
       case AppliedType(tycon, args)
       if defn.isNonRefinedFunction(tp) && isTopLevel =>
-        original match
-          case AppliedType(`tycon`, args0) if args0.last ne args.last =>
-            // We have an applied type that underwent some addition of capture sets.
-            // Map to a dependent type so that things are more uniform.
-            depFun(args.init, args.last,
-              isContextual = defn.isContextFunctionClass(tycon.classSymbol))
-                .showing(i"add function refinement $tp ($tycon, ${args.init}, ${args.last}) --> $result", capt)
-          case _ => tp
+        // Expand if we have an applied type that underwent some addition of capture sets
+        val expand = expandAlways || original.match
+          case AppliedType(`tycon`, args0) => args0.last ne args.last
+          case _ => false
+        if expand then
+          depFun(args.init, args.last,
+            isContextual = defn.isContextFunctionClass(tycon.classSymbol))
+              .showing(i"add function refinement $tp ($tycon, ${args.init}, ${args.last}) --> $result", capt)
+        else tp
       case _ => tp
 
     /** Pull out an embedded capture set from a part of `tp` */
@@ -334,8 +336,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     def fail(msg: Message) =
       if !tptToCheck.isEmpty then report.error(msg, tptToCheck.srcPos)
 
-    val toCapturing = new DeepTypeMap with SetupTypeMap:
-      override def toString = "expand aliases"
+    object toCapturing extends DeepTypeMap, SetupTypeMap:
+      override def toString = "transformExplicitType"
+
+      var keepFunAliases = true
+      var keptFunAliases = false
 
       /** Expand $throws aliases. This is hard-coded here since $throws aliases in stdlib
         * are defined with `?=>` rather than `?->`.
@@ -425,21 +430,33 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           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))
+          if defn.isNonRefinedFunction(t)
+              && !defn.isFunctionSymbol(t.typeSymbol) && (t.dealias ne tp) =>
+            if keepFunAliases then
+              // Hold off with dealising and expand in a second pass.
+              // This is necessary to bind existentialFresh instances to the right method binder.
+              keptFunAliases = true
+              mapOver(t)
+            else
+              // In the second pass, map the alias and make sure it has the form
+              // of a dependent function.
+              normalizeFunctions(apply(t.dealias), t, expandAlways = true)
           case t =>
             defaultApply(t)
     end toCapturing
 
-    val tp1 = toCapturing(tp)
-    val tp2 = Existential.mapCapInResults(fail)(tp1)
-    if tp2 ne tp then capt.println(i"expanded explicit in ${ctx.owner}: $tp  -->  $tp1  -->  $tp2")
-    tp2
+    def transform(tp: Type): Type =
+      val tp1 = toCapturing(tp)
+      val tp2 = Existential.mapCapInResults(fail, toCapturing.keepFunAliases)(tp1)
+      val snd = if toCapturing.keepFunAliases then "" else " 2nd time"
+      if tp2 ne tp then capt.println(i"expanded explicit$snd in ${ctx.owner}: $tp  -->  $tp1  -->  $tp2")
+      tp2
+
+    val tp1 = transform(tp)
+    if toCapturing.keptFunAliases then
+      toCapturing.keepFunAliases = false
+      transform(tp1)
+    else tp1
   end transformExplicitType
 
   /** Substitute parameter symbols in `from` to paramRefs in corresponding

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

@@ -804,7 +804,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             (tp1.signature consistentParams tp2.signature) &&
             matchingMethodParams(tp1, tp2) &&
             (!tp2.isImplicitMethod || tp1.isImplicitMethod) &&
-            CCState.inOpenedFreshBinder(tp2):
+            CCState.inNewExistentialScope(tp2):
               isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
           case _ => false
         }

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -260,9 +260,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
           def isUniversal =
             refs.elems.size == 1
             && (refs.isUniversal
-                || refs.elems.nth(0).match
+                || !printDebug && !showUniqueIds && refs.elems.nth(0).match
                       case Existential.Vble(binder) =>
-                        CCState.openedFreshBinders match
+                        CCState.openExistentialScopes match
                           case b :: _ => binder eq b
                           case _ => false
                       case _ =>
@@ -301,7 +301,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           ~ paramsText(tp)
           ~ ")"
           ~ (Str(": ") provided !tp.resultType.isInstanceOf[MethodOrPoly])
-          ~ CCState.inOpenedFreshBinder(tp)(toText(tp.resultType))
+          ~ CCState.inNewExistentialScope(tp)(toText(tp.resultType))
         }
       case ExprType(restp) =>
         def arrowText: Text = restp match
@@ -456,7 +456,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case MaybeCapability(tp1) => toTextCaptureRef(tp1) ~ "?"
       case Existential.Vble(binder) =>
         // TODO: Better printing? USe a mode where we print more detailed
-        val vbleText: Text = CCState.openedFreshBinders.indexOf(binder) match
+        val vbleText: Text = CCState.openExistentialScopes.indexOf(binder) match
           case -1 =>
             "<cap of " ~ toText(binder) ~ ">"
           case n => "outer_" * n ++ "cap"

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -165,9 +165,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     val capturesRoot = refs == rootSetText
     val isPure =
       Feature.pureFunsEnabled && !tsym.name.isImpureFunction && !capturesRoot
-    toTextFunction(args.init, args.last, refs.provided(!capturesRoot), isContextual, isPure)
+    toTextFunction(args.init, args.last, tp, refs.provided(!capturesRoot), isContextual, isPure)
 
-  private def toTextFunction(args: List[Type], res: Type, refs: Text,
+  private def toTextFunction(args: List[Type], res: Type, fn: MethodType | AppliedType, refs: Text,
       isContextual: Boolean, isPure: Boolean): Text =
     changePrec(GlobalPrec):
       val argStr: Text = args match
@@ -178,7 +178,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           "("
           ~ argsText(args)
           ~ ")"
-      argStr ~ " " ~ arrow(isContextual, isPure) ~ refs ~ " " ~ argText(res)
+      argStr ~ " " ~ arrow(isContextual, isPure) ~ refs ~ " "
+      ~ fn.match
+          case fn: MethodType => CCState.inNewExistentialScope(fn)(argText(res))
+          case _ => argText(res)
 
   protected def toTextMethodAsFunction(info: Type, isPure: Boolean, refs: Text = Str("")): Text =
     def recur(tp: Type, enclInfo: MethodType | Null): Text = tp match
@@ -190,8 +193,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             && !showUniqueIds && !printDebug
         then
           // cc.Setup converts all functions to dependent functions. Undo that when printing.
-          CCState.inOpenedFreshBinder(tp):
-            toTextFunction(tp.paramInfos, tp.resType, refs.provided(!capturesRoot), isContextual, isPure && !capturesRoot)
+          toTextFunction(tp.paramInfos, tp.resType, tp, refs.provided(!capturesRoot), isContextual, isPure && !capturesRoot)
         else
           changePrec(GlobalPrec):
             "("
@@ -209,7 +211,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           ~ recur(tp.resultType, enclInfo)
         }
       case _ =>
-        if enclInfo != null then CCState.inOpenedFreshBinder(enclInfo)(toText(tp))
+        if enclInfo != null then CCState.inNewExistentialScope(enclInfo)(toText(tp))
         else toText(tp)
     recur(info, null)
 

tests/neg-custom-args/captures/cc-existential-conformance.check

@@ -0,0 +1,7 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/cc-existential-conformance.scala:8:24 --------------------
+8 |  val y: A -> Fun[B^] = x // error
+  |                        ^
+  |                        Found:    (x : A -> A -> B^)
+  |                        Required: A -> A -> B^{outer_cap}
+  |
+  | longer explanation available when compiling with `-explain`