Add missing CaptureSet.ofType case for RetainingTypes

Author: odersky

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

@@ -1360,6 +1360,8 @@ object CaptureSet:
           else empty
         case CapturingType(parent, refs) =>
           recur(parent) ++ refs
+        case tp @ AnnotatedType(parent, ann) if ann.symbol.isRetains =>
+          recur(parent) ++ ann.tree.toCaptureSet
         case tpd @ defn.RefinedFunctionOf(rinfo: MethodType) if followResult =>
           ofType(tpd.parent, followResult = false)            // pick up capture set from parent type
           ++ recur(rinfo.resType)                             // add capture set of result

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

@@ -17,6 +17,7 @@ import scala.annotation.unchecked.uncheckedVariance
 import scala.collection.mutable.Builder
 import scala.collection.View.{LeftPartitionMapped, RightPartitionMapped}
 import language.experimental.captureChecking
+import scala.caps.unsafe.unsafeAssumePure
 
 /** Base trait for generic collections.
   *
@@ -302,7 +303,8 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] with Iterable
     * this.sizeIs > size     // this.sizeCompare(size) > 0
     * }}}
     */
-  @inline final def sizeIs: IterableOps.SizeCompareOps^{this} = new IterableOps.SizeCompareOps(this)
+  @inline final def sizeIs: IterableOps.SizeCompareOps^{this} = new IterableOps.SizeCompareOps(this.unsafeAssumePure)
+    // CC Problem: unsafeAssumePure needed since we had to change the argument signatire of SizeCompareOps
 
   /** Compares the size of this $coll to the size of another `Iterable`.
     *
@@ -866,8 +868,15 @@ object IterableOps {
     * These operations are implemented in terms of
     * [[scala.collection.IterableOps.sizeCompare(Int) `sizeCompare(Int)`]].
     */
-  final class SizeCompareOps private[collection](val it: IterableOps[_, AnyConstr, _]^) extends AnyVal {
-    this: SizeCompareOps^{it} =>
+  final class SizeCompareOps private[collection](val it: IterableOps[_, AnyConstr, _]/*^*/) extends AnyVal {
+    this: SizeCompareOps/*^*/ =>
+    // CC Problem: if we add the logically needed `^`s to the `it` parameter and the
+    // self type, separation checking fails in the compiler-generated equals$extends
+    // method of the value class. There seems to be something wrong how pattern
+    // matching interacts with separation checking. A minimized test case
+    // is pending/pos-custom-args/captures/SizeCompareOps-redux.scala.
+    // Without the `^`s, the `sizeIs` method needs an unsafeAssumePure.
+
     /** Tests if the size of the collection is less than some value. */
     @inline def <(size: Int): Boolean = it.sizeCompare(size) < 0
     /** Tests if the size of the collection is less than or equal to some value. */

tests/neg-custom-args/captures/capture-vars-subtyping.scala

@@ -1,4 +1,5 @@
 import language.experimental.captureChecking
+import language.`3.7` // no separation checking, TODO enable
 import caps.*
 
 def test[C^] =

tests/neg-custom-args/captures/capture-vars-subtyping2.scala

@@ -25,7 +25,8 @@ trait BoundsTest:
     val ec2: CapSet^{C} = e
     val eb: B = e
     val eb2: CapSet^{B} = e
-    val ea: A = e
+    locally:
+      val ea: A = e
     val ea2: CapSet^{A} = e
     val ex: X = e            // error
     val ex2: CapSet^{X} = e // error

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

@@ -39,46 +39,46 @@
    |             ^^^^
    |             Separation failure: Illegal access to {cap1} which is hidden by the previous definition
    |             of value ref2 with type LazyRef[Int]{val elem: () => Int}^{cap2, ref1}.
-   |             This type hides capabilities  {cap1}
+   |             This type hides capabilities  {LazyRef.this.elem, cap1}
    |
    |             where:    => refers to a fresh root capability in the type of value elem
 -- Error: tests/neg-custom-args/captures/lazyref.scala:26:9 ------------------------------------------------------------
 26 |      if cap1 == cap2   // error: separation failure // error: separation failure
    |         ^^^^
    |         Separation failure: Illegal access to {cap1} which is hidden by the previous definition
    |         of value ref3 with type LazyRef[Int]{val elem: () => Int}^{cap2, ref1}.
-   |         This type hides capabilities  {ref2*, cap1}
+   |         This type hides capabilities  {LazyRef.this.elem, ref2*, cap1}
    |
    |         where:    => refers to a fresh root capability in the type of value elem
 -- Error: tests/neg-custom-args/captures/lazyref.scala:26:17 -----------------------------------------------------------
 26 |      if cap1 == cap2   // error: separation failure // error: separation failure
    |                 ^^^^
    |                 Separation failure: Illegal access to {cap2} which is hidden by the previous definition
    |                 of value ref3 with type LazyRef[Int]{val elem: () => Int}^{cap2, ref1}.
-   |                 This type hides capabilities  {ref2*, cap1}
+   |                 This type hides capabilities  {LazyRef.this.elem, ref2*, cap1}
    |
    |                 where:    => refers to a fresh root capability in the type of value elem
 -- Error: tests/neg-custom-args/captures/lazyref.scala:27:11 -----------------------------------------------------------
 27 |      then ref1 // error: separation failure
    |           ^^^^
    |           Separation failure: Illegal access to {cap1, ref1} which is hidden by the previous definition
    |           of value ref3 with type LazyRef[Int]{val elem: () => Int}^{cap2, ref1}.
-   |           This type hides capabilities  {ref2*, cap1}
+   |           This type hides capabilities  {LazyRef.this.elem, ref2*, cap1}
    |
    |           where:    => refers to a fresh root capability in the type of value elem
 -- Error: tests/neg-custom-args/captures/lazyref.scala:28:11 -----------------------------------------------------------
 28 |      else ref2) // error: separation failure
    |           ^^^^
    |           Separation failure: Illegal access to {cap1, cap2, ref1} which is hidden by the previous definition
    |           of value ref3 with type LazyRef[Int]{val elem: () => Int}^{cap2, ref1}.
-   |           This type hides capabilities  {ref2*, cap1}
+   |           This type hides capabilities  {LazyRef.this.elem, ref2*, cap1}
    |
    |           where:    => refers to a fresh root capability in the type of value elem
 -- Error: tests/neg-custom-args/captures/lazyref.scala:29:9 ------------------------------------------------------------
 29 |    .map(g) // error: separation failure
    |         ^
    |         Separation failure: Illegal access to {cap2} which is hidden by the previous definition
    |         of value ref3 with type LazyRef[Int]{val elem: () => Int}^{cap2, ref1}.
-   |         This type hides capabilities  {ref2*, cap1}
+   |         This type hides capabilities  {LazyRef.this.elem, ref2*, cap1}
    |
    |         where:    => refers to a fresh root capability in the type of value elem

tests/neg-custom-args/captures/sep-curried-redux.scala

@@ -0,0 +1,18 @@
+import language.experimental.captureChecking
+import caps.*
+
+class Ref[T](init: T) extends Mutable:
+  private var value: T = init
+  def get: T = value
+  mut def set(newValue: T): Unit = value = newValue
+
+// a library function that assumes that a and b MUST BE separate
+def swap[T](a: Ref[Int]^, b: Ref[Int]^): Unit = ???
+
+def test4(): Unit =
+  val a: Ref[Int]^ = Ref(0)
+  val foo: (x: Ref[Int]^) -> (y: Ref[Int]^) ->{x} Unit =
+    x => y => swap(x, y)
+  val f = foo(a)
+  f(a) // error
+

tests/pending/pos-custom-args/captures/SizeCompareOps-redux.scala

@@ -0,0 +1,22 @@
+package collection
+trait IterableOps[+A, +CC[_], +C] extends Any:
+  def sizeCompare(size: Int): Int
+
+object IterableOps:
+
+  type AnyConstr[X] = Any
+
+  final class SizeCompareOps private[collection](val it: IterableOps[_, AnyConstr, _]^) extends AnyVal:
+    this: SizeCompareOps^{it} =>
+    /** Tests if the size of the collection is less than some value. */
+    @inline def <(size: Int): Boolean = it.sizeCompare(size) < 0
+    /** Tests if the size of the collection is less than or equal to some value. */
+    @inline def <=(size: Int): Boolean = it.sizeCompare(size) <= 0
+    /** Tests if the size of the collection is equal to some value. */
+    @inline def ==(size: Int): Boolean = it.sizeCompare(size) == 0
+    /** Tests if the size of the collection is not equal to some value. */
+    @inline def !=(size: Int): Boolean = it.sizeCompare(size) != 0
+    /** Tests if the size of the collection is greater than or equal to some value. */
+    @inline def >=(size: Int): Boolean = it.sizeCompare(size) >= 0
+    /** Tests if the size of the collection is greater than some value. */
+    @inline def >(size: Int): Boolean = it.sizeCompare(size) > 0