Recognize double annotated capabilities such as x*?

x*? is x.type @reach @maybe. This was not recognized before.

Author: odersky

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

@@ -639,8 +639,8 @@ object CapsOfApply:
 class AnnotatedCapability(annot: Context ?=> ClassSymbol):
   def apply(tp: Type)(using Context) =
     AnnotatedType(tp, Annotation(annot, util.Spans.NoSpan))
-  def unapply(tree: AnnotatedType)(using Context): Option[SingletonCaptureRef] = tree match
-    case AnnotatedType(parent: SingletonCaptureRef, ann) if ann.symbol == annot => Some(parent)
+  def unapply(tree: AnnotatedType)(using Context): Option[CaptureRef] = tree match
+    case AnnotatedType(parent: CaptureRef, ann) if ann.symbol == annot => Some(parent)
     case _ => None
 
 /** An extractor for `ref @annotation.internal.reachCapability`, which is used to express

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

@@ -0,0 +1,13 @@
+import language.experimental.captureChecking
+import caps.Capability
+
+trait File extends Capability
+
+class Resource[T <: Capability](gen: T):
+  def use[U](f: T => U): U =
+    f(gen) // error
+
+@main def run =
+  val myFile: File = ???
+  val r = Resource(myFile) // error
+  ()

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

@@ -0,0 +1,20 @@
+class C
+def test(x: C^, y: C^) =
+  class D {
+    println(x)
+    def foo() = println(y)
+  }
+  val d = D()
+  val _: D^{y} = d // error, should be ok
+  val _: D = d // error
+
+  val f = () => println(D())
+  val _: () ->{x} Unit = f // ok
+  val _: () -> Unit = f // should be error
+
+  def g = () =>
+    println(x)
+    () => println(y)
+  val _: () ->{x} () ->{y} Unit = g // error, should be ok
+  val _: () -> () -> Unit = g // error
+