Fixes in language reference and tests cases

Author: bracevac

docs/_docs/reference/experimental/cc.md

@@ -776,7 +776,7 @@ A common use-case for explicit capture parameters is describing changes to the c
 effectful iterators:
 ```scala
 class ConcatIterator[A, C^](var iterators: mutable.List[IterableOnce[A]^{C}]):
-  def concat(it: IterableOnce[A]^): ConcatIterator[A, {this.C, it}]^{this, it} =
+  def concat(it: IterableOnce[A]^): ConcatIterator[A, {C, it}]^{this, it} =
     iterators ++= it                             //            ^
     this                                         // track contents of `it` in the result
 ```

tests/neg-custom-args/captures/capset-members.scala

@@ -27,30 +27,4 @@ class Concrete5(a: AnyRef^, b: AnyRef^) extends Abstract[{a}]:
   def boom(): AnyRef^{b} = b // error
 
 class Concrete6(a: AnyRef^, b: AnyRef^) extends Abstract[{a}]:
-  def boom(): AnyRef^{b} = b // error
-
-
-trait Ctx[T]
-
-def test =
-  val x: Any^ = ???
-  val y: Any^ = ???
-  object O:
-    val z: Any^ = ???
-  trait CaptureSet:
-    type A^ >: {y} <: {x}
-    type B = {x}
-    type C <: {x}
-    type D^ : Ctx // error
-    type E <: {C}
-    type F <: {C}
-    type G <: {x, y}
-    type H >: {x} <: {x,y} : Ctx // error
-    type I^ = {y, G, H}
-    type J = {O.z}
-    type K^ = {x, O.z}
-    type L <: {x, y, O.z}
-    type M >: {x, y, O.z} <: {C}
-    type N >: {x} <: {x}
-    type O >: {O.z} <: {O.z}
-    type P >: {B,D} // error
+  def boom(): AnyRef^{b} = b // error

tests/neg-custom-args/captures/capset-members5.scala

@@ -0,0 +1,27 @@
+import language.experimental.captureChecking
+import caps.*
+
+trait Ctx[T]
+
+def test =
+  val x: Any^ = ???
+  val y: Any^ = ???
+  object O:
+    val z: Any^ = ???
+  trait CaptureSet:
+    type A^ >: {y} <: {x}
+    type B = {x}
+    type C <: {x}
+    type D^ : Ctx // error
+    type E <: {C}
+    type F <: {C}
+    type G <: {x, y}
+    type H >: {x} <: {x,y} : Ctx // error
+    type I^ = {y, G, H}
+    type J = {O.z}
+    type K^ = {x, O.z}
+    type L <: {x, y, O.z}
+    type M >: {x, y, O.z} <: {C}
+    type N >: {x} <: {x}
+    type O >: {O.z} <: {O.z}
+    type P >: {B,D} // error