Issue with classes taking capabilities only in their method parameters

[odersky]

Compiler version

3.8.0

Minimized example

import language.experimental.captureChecking
import language.experimental.separationChecking
import caps.*
def par(p1: () => Unit, p2: () => Unit): Unit = ???
def test(c: () => Unit): Unit =
  trait Runner:
    def runPar(p2: () ->{c} Unit): Unit
  class SomeRunner(p1: () => Unit) extends Runner:
    def runPar(p2: () ->{c} Unit): Unit =
      par(p1, p2)
  val bad = (p1: () => Unit) =>
    val r = SomeRunner(p1)
    r
  val runner: Runner^{c} = bad(c)
  runner.runPar(c)  // boom, will run `c` and `c` in parallel

Output

Compiles

Expectation

Should give an error because we end up doing a par with c and c.

[odersky]

If Runner was a lambda the call to bad would be illegal

val runner: Runner^{c} = bad(c)

because the function result refers to a capture of the function in its parameter. But for classes this looks difficult to enforce.

An alternative could be to reject the call par(p1, p2) in `

def runPar(p2: () ->{c} Unit): Unit =
      par(p1, p2)

This would be on the grounds that p1 cannot be guaranteed to be separate from p2 since p2's capture {c} is not also a capture of class Runner.