Add implied captures in function types

This is an attempt to fix the problem explified in the `delayedRunops*.scala` tests.
We can treat it as a baseline that fixes the immediate problem of the interaction of
reach capabilities and type variables. There might be better ways to do this by using
a proper adapation rule for function types instead of adding implied captures post-hoc.

Author: odersky

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

@@ -527,6 +527,14 @@ extension (tp: Type)
       case _ =>
         tp
 
+  /** Add implied captures as defined by `CaptureSet.addImplied`. */
+  def withImpliedCaptures(using Context): Type =
+    if tp.isValueType && !tp.isAlwaysPure then
+      val implied = CaptureSet.addImplied()(CaptureSet.empty, tp)
+      if !implied.isAlwaysEmpty then capt.println(i"Add implied $implied to $tp")
+      tp.capturing(implied)
+    else tp
+
   def level(using Context): Level =
     tp match
     case tp: TermRef => tp.symbol.ccLevel

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

@@ -1068,6 +1068,39 @@ object CaptureSet:
       .showing(i"Deep capture set of $ref: ${ref1.widen} = $result", capt)
     case _ => ofType(ref.underlying, followResult = true)
 
+  /** Add captures implied by a type. This means: if we have a contravarint, boxed
+   *  capability in a function parameter and the capability is either `cap`, or a
+   *  reach capability, or a capture set variable, add the same capability to the enclosing
+   *  function arrow. For instance `List[() ->{ops*} Unit] -> Unit` would become
+   *  `List[() ->{ops*} Unit] ->{ops*} Unit`. This is needed to make
+   *  the `delayedRunops*.scala` tests produce errors.
+   *  TODO: Investigate whether we can roll this into a widening rule like
+   *
+   *      List[() ->{cap} Unit] -> Unit <: List[() ->{ops*} Unit] ->{ops*} Unit
+   *
+   *  but not
+   *
+   *      List[() ->{cap} Unit] -> Unit <: List[() ->{ops*} Unit] -> Unit
+   *
+   *  It would mean that a reach capability can no longer be a subtype of `cap`.
+   */
+  class addImplied(using Context) extends TypeAccumulator[CaptureSet]:
+    var boundVars: Set[CaptureRef] = Set.empty
+    def isImplied(tp: CaptureRef) =
+      (tp.isRootCapability || tp.isReach || tp.derivesFrom(defn.Caps_CapSet))
+      && !boundVars.contains(tp.stripReach)
+    def apply(cs: CaptureSet, t: Type) = t match
+      case t @ CapturingType(parent, cs1) =>
+        val cs2 = this(cs, parent)
+        if variance <= 0 && t.isBoxed then cs2 ++ cs1.filter(isImplied)
+        else cs2
+      case t: MethodOrPoly =>
+        val saved = boundVars
+        boundVars ++= t.paramRefs.asInstanceOf[List[CaptureRef]]
+        try foldOver(cs, t) finally boundVars = saved
+      case _ =>
+        foldOver(cs, t)
+
   /** Capture set of a type */
   def ofType(tp: Type, followResult: Boolean)(using Context): CaptureSet =
     def recur(tp: Type): CaptureSet = trace(i"ofType $tp, ${tp.getClass} $followResult", show = true):

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

@@ -1292,7 +1292,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       else
         val widened = improveCaptures(actual.widen.dealiasKeepAnnots, actual)
         val adapted = adaptBoxed(
-            widened.withReachCaptures(actual), expected, pos,
+            widened.withReachCaptures(actual).withImpliedCaptures, expected, pos,
             covariant = true, alwaysConst = false, boxErrors)
         if adapted eq widened then actual
         else adapted.showing(i"adapt boxed $actual vs $expected = $adapted", capt)

scala2-library-cc/src/scala/collection/SeqView.scala

@@ -212,7 +212,7 @@ object SeqView {
       override def sorted[B1 >: A](implicit ord1: Ordering[B1]): SeqView[A]^{this} =
         if (ord1 == Sorted.this.ord) outer.unsafeAssumePure
         else if (ord1.isReverseOf(Sorted.this.ord)) this
-        else new Sorted(elems, len, ord1)
+        else new Sorted(elems, len, ord1).asInstanceOf // !!! asInstanceOf needed after adding addImplied widening
     }
 
     @volatile private[this] var evaluated = false

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

@@ -0,0 +1,14 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/delayedRunops2.scala:10:35 -------------------------------
+10 |  app[List[() ->{ops*} Unit], Unit](ops, runOps) // error
+   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |  Found:    () ->{ops*} Unit
+   |  Required: () -> Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/delayedRunops2.scala:18:36 -------------------------------
+18 |  app2[List[() => Unit], Unit](ops, runOps: List[() => Unit] -> Unit) // error
+   |                                    ^^^^^^
+   |                                    Found:    (ops: List[box () ->? Unit]^?) ->? Unit
+   |                                    Required: (ops: List[box () => Unit]) -> Unit
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/delayedRunops2.scala

@@ -0,0 +1,22 @@
+import language.experimental.captureChecking
+
+def runOps(ops: List[() => Unit]): Unit =
+  ops.foreach(op => op())
+
+def app[T, U](x: T, op: T => U): () ->{op} U =
+  () => op(x)
+
+def unsafeRunOps(ops: List[() => Unit]): () ->{} Unit =
+  app[List[() ->{ops*} Unit], Unit](ops, runOps) // error
+
+def app2[T, U](x: T, op: T => U): () ->{op} U =
+  () =>
+    def y: T = x
+    op(y)
+
+def unsafeRunOps2(ops: List[() => Unit]): () -> Unit =
+  app2[List[() => Unit], Unit](ops, runOps: List[() => Unit] -> Unit) // error
+
+
+
+

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

@@ -0,0 +1,10 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/delayedRunops3.scala:10:41 -------------------------------
+10 |  app[List[() ->{ops*} Unit], Unit](ops, runOps) // error
+   |                                         ^^^^^^
+   |                                         Found:    (ops: List[box () ->? Unit]^?) ->? Unit
+   |                                         Required: (ops: List[box () ->{ops²*} Unit]) -> Unit
+   |
+   |                                         where:    ops  is a reference to a value parameter
+   |                                                   ops² is a parameter in method unsafeRunOps
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/delayedRunops3.scala

@@ -0,0 +1,14 @@
+import language.experimental.captureChecking
+
+def runOps(ops: List[() => Unit]): Unit =
+  ops.foreach(op => op())
+
+def app[T, U](x: T, op: T -> U): () ->{} U =
+  () => op(x)
+
+def unsafeRunOps(ops: List[() => Unit]): () ->{} Unit =
+  app[List[() ->{ops*} Unit], Unit](ops, runOps) // error
+
+
+
+

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

@@ -0,0 +1,21 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/delayedRunops4.scala:11:4 --------------------------------
+11 |    runOps[C]: List[() ->{C^} Unit] ->{C^} Unit) // error
+   |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |    Found:    List[box () ->{C^} Unit] ->{C^} Unit
+   |    Required: List[box () ->{C^} Unit] -> Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/delayedRunops4.scala:15:43 -------------------------------
+15 |  app[List[() ->{C^} Unit], Unit](ops, rops[C]) // error
+   |                                       ^^^^^^^
+   |                                       Found:    (ops: List[box () ->{C^} Unit]) ->{C^} Unit
+   |                                       Required: (ops: List[box () ->{C^} Unit]) -> Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/delayedRunops4.scala:18:39 -------------------------------
+18 |  app[List[() ->{C^} Unit], Unit](ops, runOps) // error
+   |                                       ^^^^^^
+   |                                       Found:    (ops: List[box () ->? Unit]^?) ->? Unit
+   |                                       Required: (ops: List[box () ->{C^} Unit]) -> Unit
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/delayedRunops4.scala

@@ -0,0 +1,24 @@
+import language.experimental.captureChecking
+
+def runOps[C^](ops: List[() ->{C^} Unit]): Unit =
+  ops.foreach(op => op())
+
+def app[T, U](x: T, op: T -> U): () ->{} U =
+  () => op(x)
+
+def unsafeRunOps[C^](ops: List[() ->{C^} Unit]): () ->{} Unit =
+  app[List[() ->{C^} Unit], Unit](ops,
+    runOps[C]: List[() ->{C^} Unit] ->{C^} Unit) // error
+
+def unsafeRunOps2[C^](ops: List[() ->{C^} Unit]): () ->{} Unit =
+  def rops[D^]: (ops: List[() ->{D^} Unit]) -> Unit = ???
+  app[List[() ->{C^} Unit], Unit](ops, rops[C]) // error
+
+def unsafeRunOps3[C^](ops: List[() ->{C^} Unit]): () ->{} Unit =
+  app[List[() ->{C^} Unit], Unit](ops, runOps) // error
+
+
+
+
+
+