Present aligned dependent functions as generic functions

Aligning an expected function type to be dependent gives the false expression that
we could have the parameter in a local capture. To avoid that misinterpretation,
convert an aligned dependent function as the expected type back to a generic functions
before displaying it in the error message.

Author: odersky

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

@@ -1337,6 +1337,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     inline def testAdapted(actual: Type, expected: Type, tree: Tree, addenda: Addenda)
         (fail: (Tree, Type, Addenda) => Unit)(using Context): Type =
       var expected1 = alignDependentFunction(expected, actual.stripCapturing)
+      val falseDeps = expected1 ne expected
       val actualBoxed = adapt(actual, expected1, tree)
       //println(i"check conforms $actualBoxed <<< $expected1")
 
@@ -1346,6 +1347,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       TypeComparer.compareResult(isCompatible(actualBoxed, expected1)) match
         case TypeComparer.CompareResult.Fail(notes) =>
           capt.println(i"conforms failed for ${tree}: $actual vs $expected")
+          if falseDeps then expected1 = unalignFunction(expected1)
           fail(tree.withType(actualBoxed), expected1,
             addApproxAddenda(addenda ++ errorNotes(notes), expected1))
           actual
@@ -1360,10 +1362,8 @@ class CheckCaptures extends Recheck, SymTransformer:
     /** Turn `expected` into a dependent function when `actual` is dependent. */
     private def alignDependentFunction(expected: Type, actual: Type)(using Context): Type =
       def recur(expected: Type): Type = expected.dealias match
-        case expected0 @ CapturingType(eparent, refs) =>
-          val eparent1 = recur(eparent)
-          if eparent1 eq eparent then expected
-          else CapturingType(eparent1, refs, boxed = expected0.isBoxed)
+        case expected @ CapturingType(eparent, refs) =>
+          expected.derivedCapturingType(recur(eparent), refs)
         case expected @ defn.FunctionOf(args, resultType, isContextual)
         if defn.isNonRefinedFunction(expected) =>
           actual match
@@ -1381,6 +1381,14 @@ class CheckCaptures extends Recheck, SymTransformer:
         case _ => expected
       recur(expected)
 
+    private def unalignFunction(tp: Type)(using Context): Type = tp match
+      case tp @ CapturingType(parent, refs) =>
+        tp.derivedCapturingType(unalignFunction(parent), refs)
+      case defn.RefinedFunctionOf(mt) =>
+        mt.toFunctionType(alwaysDependent = false)
+      case _ =>
+        tp
+
     /** For the expected type, implement the rule outlined in #14390:
      *   - when checking an expression `a: Ta^Ca` against an expected type `Te^Ce`,
      *   - where the capture set `Ce` contains Cls.this,

tests/neg-custom-args/captures/box-adapt-cases.check

@@ -2,7 +2,7 @@
 8 |  x.value(cap => cap.use())  // error, was OK
   |          ^^^^^^^^^^^^^^^^
   |          Found:    (cap: box Cap^?) => Int
-  |          Required: (cap: box Cap^) =>² Int
+  |          Required: box Cap^ =>² Int
   |
   |          where:    =>  refers to the universal root capability
   |                    =>² refers to a fresh root capability created in method test1
@@ -13,13 +13,13 @@
 15 |  x.value(cap => cap.use())  // error
    |          ^^^^^^^^^^^^^^^^
    |          Found:    (cap: box Cap^{io}) ->{io} Int
-   |          Required: (cap: box Cap^{io}) -> Int
+   |          Required: box Cap^{io} -> Int
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/box-adapt-cases.scala:29:10 ------------------------------
 29 |  x.value(cap => cap.use())  // error
    |          ^^^^^^^^^^^^^^^^
    |          Found:    (cap: box Cap^?) ->{io, fs} Int
-   |          Required: (cap: box Cap^{io, fs}) ->{io} Int
+   |          Required: box Cap^{io, fs} ->{io} Int
    |
    | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/depfun-reach.check

@@ -2,7 +2,7 @@
 12 |    List(() => op.foreach((f,g) => { f(); g() })) // error (???)
    |                           ^^^^^^^^^^^^^^^^^^^^
    |Found:    (x$1: (box () ->? Unit, box () ->? Unit)^?) ->? Unit
-   |Required: (x$1: (box () ->{op*} Unit, box () ->{op*} Unit)) => Unit
+   |Required: ((box () ->{op*} Unit, box () ->{op*} Unit)) => Unit
    |
    |where:    => refers to a fresh root capability created in anonymous function of type (): Unit when checking argument to parameter op of method foreach
    |

tests/neg-custom-args/captures/effect-swaps-explicit.check

@@ -19,21 +19,21 @@
    |          ^
    |Found:    (contextual$9: boundary.Label[box Result[box Future[box T^?]^?, box E^?]^?]^) ?->{fr, async}
    |  box Future[box T^?]^{fr, contextual$9}
-   |Required: (contextual$9: boundary.Label[Result[box Future[box T^?]^?, box E^?]]^) ?=> box Future[box T^?]^?
+   |Required: (boundary.Label[Result[box Future[box T^?]^{fr, async}, box E^?]]^) ?=> box Future[box T^?]^{fr, async}
    |
    |where:    ?=> refers to a fresh root capability created in method fail4 when checking argument to parameter body of method make
    |          ^   refers to the universal root capability
    |
    |Note that reference contextual$9.type
-   |cannot be included in outer capture set ?
+   |cannot be included in outer capture set {fr, async}
 70 |            fr.await.ok
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/effect-swaps-explicit.scala:73:35 ------------------------
 73 |        Result.make[Future[T], E]: lbl ?=> // error: type mismatch
    |                                   ^
    |Found:    (lbl: boundary.Label[box Result[box Future[box T^?]^?, box E^?]^?]^) ?->{fr, async} Future[box T^?]^{fr, lbl}
-   |Required: (lbl: boundary.Label[Result[Future[T], E]]^) ?=> Future[T]
+   |Required: (boundary.Label[Result[Future[T], E]]^) ?=> Future[T]
    |
    |where:    ?=> refers to a fresh root capability created in method fail5 when checking argument to parameter body of method make
    |          ^   refers to the universal root capability

tests/neg-custom-args/captures/effect-swaps.check

@@ -19,21 +19,21 @@
    |          ^
    |Found:    (contextual$9: boundary.Label[box Result[box Future[box T^?]^?, box E^?]^?]^{cap.rd}) ?->{fr, async}
    |  box Future[box T^?]^{fr, contextual$9}
-   |Required: (contextual$9: boundary.Label[Result[box Future[box T^?]^?, box E^?]]^{cap.rd}) ?=> box Future[box T^?]^?
+   |Required: (boundary.Label[Result[box Future[box T^?]^{fr, async}, box E^?]]^{cap.rd}) ?=> box Future[box T^?]^{fr, async}
    |
    |where:    ?=> refers to a fresh root capability created in method fail4 when checking argument to parameter body of method make
    |          cap is the universal root capability
    |
    |Note that reference contextual$9.type
-   |cannot be included in outer capture set ?
+   |cannot be included in outer capture set {fr, async}
 70 |            fr.await.ok
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/effect-swaps.scala:73:35 ---------------------------------
 73 |        Result.make[Future[T], E]: lbl ?=> // error: type mismatch
    |                                   ^
    |Found:    (lbl: boundary.Label[box Result[box Future[box T^?]^?, box E^?]^?]^{cap.rd}) ?->{fr, async} Future[box T^?]^{fr, lbl}
-   |Required: (lbl: boundary.Label[Result[Future[T], E]]^{cap.rd}) ?=> Future[T]
+   |Required: (boundary.Label[Result[Future[T], E]]^{cap.rd}) ?=> Future[T]
    |
    |where:    ?=> refers to a fresh root capability created in method fail5 when checking argument to parameter body of method make
    |          cap is the universal root capability

tests/neg-custom-args/captures/heal-tparam-cs.check

@@ -50,7 +50,7 @@
 44 |    io => () => io.use()  // error
    |    ^^^^^^^^^^^^^^^^^^^^
    |    Found:    (io: Capp^) ->? () ->{io} Unit
-   |    Required: (io: Capp^) -> () -> Unit
+   |    Required: Capp^ -> () -> Unit
    |
    |    where:    ^ refers to the universal root capability
    |

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

@@ -2,7 +2,7 @@
 13 |    (ref1, f1) => map[A, B](ref1, f1) // error
    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |Found:    (ref1: LazyRef[box A^?]{val elem: () => A^?}^{io}, f1: A^? => B^?) ->? LazyRef[box B^?]{val elem: () =>² B^?}^{f1, ref1}
-   |Required: (ref1: LazyRef[A]^{io}, f1: A => B) =>³ LazyRef[B]^
+   |Required: (LazyRef[A]^{io}, A => B) =>³ LazyRef[B]^
    |
    |where:    =>  refers to the universal root capability
    |          =>² refers to a root capability associated with the result type of (ref1: LazyRef[box A^?]{val elem: () => A^?}^{io}, f1: A^? => B^?): LazyRef[box B^?]{val elem: () =>² B^?}^{f1, ref1}

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

@@ -16,7 +16,7 @@
 15 |  val a = usingIO[IO^](x => x) // error // error
    |                       ^^^^^^
    |Found:    (x: IO^) ->? box IO^{x}
-   |Required: (x: IO^) => box IO^²
+   |Required: IO^ => box IO^²
    |
    |where:    => refers to a fresh root capability created in value a when checking argument to parameter op of method usingIO
    |          ^  refers to the universal root capability
@@ -48,7 +48,7 @@
 17 |  val x: Boxed[IO^] = leaked[Boxed[IO^], Boxed[IO^] -> Boxed[IO^]](x => x) // error // error // error
    |                                                                   ^^^^^^
    |                                              Found:    (x: Boxed[box IO^]^?) ->? Boxed[box IO^{x*}]^?
-   |                                              Required: (x: Boxed[box IO^]) -> Boxed[box IO^²]
+   |                                              Required: Boxed[box IO^] -> Boxed[box IO^²]
    |
    |                                              where:    ^  refers to the universal root capability
    |                                                        ^² refers to a fresh root capability created in value x²

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

@@ -11,7 +11,7 @@
 15 |  files.map(new Logger(_)) // error, Q: can we improve the error message?
    |            ^^^^^^^^^^^^^
    |Found:    (_$1: box File^{files*}) ->{files*} box Logger{val f: File^{_$1}}^{cap.rd, _$1}
-   |Required: (_$1: box File^{files*}) => box Logger{val f: File^?}^?
+   |Required: box File^{files*} => box Logger{val f: File^?}^?
    |
    |where:    =>  refers to a fresh root capability created in method mkLoggers2 when checking argument to parameter f of method map
    |          cap is a root capability associated with the result type of (_$1: box File^{files*}): box Logger{val f: File^{_$1}}^{cap.rd, _$1}

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

@@ -2,7 +2,7 @@
 34 |  val cell: Cell[File] = File.open(f => Cell(() => Seq(f))) // error
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^
    |Found:    (f: File^?) ->? box Cell[box File^?]{val head: () ->? IterableOnce[box File^?]^?}^?
-   |Required: (f: File^) => box Cell[box File^?]{val head: () ->? IterableOnce[box File^?]^?}^?
+   |Required: File^ => box Cell[box File^?]{val head: () ->? IterableOnce[box File^?]^?}^?
    |
    |where:    => refers to a fresh root capability created in value cell when checking argument to parameter f of method open
    |          ^  refers to the universal root capability