Fix #21868, #21869, and #21870: handle CapsOf in more places

[noti0na1]

Fix #21868, #21869, and #21870

[noti0na1]

@odersky Do you remember why we require the arguments of CapsOf to be abstract before? I think any type derived from CapSet should work.

[bracevac]

Strange, we're consistently getting a CI failure Errors found on incorrect row numbers when compiling tests/vulpix-tests/unit/negNoPositionAnnots.scala. That does not look related at all to the changes.
Edit: it's actually the new test case test/neg-custom-args/captures/i21868.scala. The log output is difficult to read.

[noti0na1]

Idealy, we'd like to retrict the capture parameter and member bounded by >: CapSet^{} <: CapSet^, which can forbid instantiating to meaningless types, like Nothing.

[bracevac]

That's certainly cleaner. The question is how far we want to take it for now. A fully general solution would also have to deal with the presence of explicit lower bounds, which could be themselves type variables, etc.

trait Abstract[L >: CapSet^{}]:
    type T >: L <: CapSet^

Maybe let's track this in a separate issue? The point of the current fix is to prevent the uncaught exception and compiler crash.

[noti0na1]

I don't think this is an issue, as long as L is also bounded by CapSet.

[bracevac]

As the below examples show, there's a still a few quirks. I'm also somewhat uneasy with automatically presuming that the lower bound of a CapSet^-bounded type variable is CapSet^{}. E.g., should this always be the case, or only with cc enabled?

Since the specific issues are resolved, let's merge this and have a separate issue to make capture set intervals and subtyping airtight.

[bracevac]

At some point, we should probably make intersection and unions work as well:

class Concrete2 extends Abstract:
    type C = CapSet^{} & CapSet^{}
    def boom() = () // error

class Concrete3 extends Abstract:
    type C = CapSet^{} | CapSet^{}
    def boom() = () // error

It's not unreasonable to expect CapSet^c1 | CapSet^c2 <:> CapSet^(c1 | c2) and CapSet^c1 & CapSet^c2 <:> CapSet^(c1 & c2).

[bracevac]

OK, so this is weird:

import language.experimental.captureChecking
import caps.*

trait Abstract[X >: Nothing]: // Concrete2 and 3 fail with this lower bound, but work with X >: CapSet^{}
    type C >: X <: CapSet^
    def boom(): Unit^{C^}

class Concrete extends Abstract[CapSet^{}]:
    type C = CapSet^{}
    def boom() = () // ok

class Concrete2 extends Abstract[CapSet^{}]:
    type C = CapSet^{} & CapSet^{}
    def boom() = () // error

class Concrete3 extends Abstract[CapSet^{}]:
    type C = CapSet^{} | CapSet^{}
    def boom() = () // error

We get (now properly reported as an error) "Illegal capture reference ..." as long as X has lower bound Nothing. It will magically work if it's lower-bounded by CapSet^{}.

[bracevac]

LGTM!