Add tests for consume in constructor parameters

Author: bracevac

tests/neg-custom-args/captures/paths-derivedcaps-consume.scala

@@ -0,0 +1,53 @@
+import language.experimental.captureChecking
+import language.experimental.separationChecking
+import caps.*
+
+class Foo extends ExclusiveCapability, Classifier
+
+// Testing with various DerivedCapabilities
+class D
+class C(val d: D)
+class B(val c: C) extends Foo, Mutable:
+  update def foo() = println("foo")
+class A(consume val b: B^) extends Mutable:
+  update def bar() = b.foo()
+class A2(consume val b: B^)
+class A3(consume var b: B^)
+class A4(consume val b: A2^{cap.only[Foo]})
+
+// Test: Access nested fields (suffix paths) after consume
+def testSuffixPaths =
+  val d: D = D()
+  val c: C = C(d)
+  val b: B^ = B(c)
+  val a1 = A(b)
+  val b2: B^ = B(c)
+  val a2 = A2(b2) // the difference is that we pass b2.rd
+  val b3: B^ = B(c)
+  val a3 = A3(b3)
+  val b4: B^ = B(c)
+  val a22 = A2(b4)
+  val a4 = A4(a22)
+  val b5: B^{cap.only[Foo]} = B(c)
+  val a5 = A(b5)
+  val b6: B^{cap.only[Foo]} = B(c)
+  val a222 = A2(b6)
+  val a6 = A4(a222)
+
+
+  println(a1.b) // ok
+  println(a2.b) // ok
+  println(a3.b) // ok
+  println(a4.b) // ok
+  println(a4.b.b) // ok
+  println(a5.b) // ok
+  println(a6.b) // ok
+  println(a6.b.b) // ok
+
+  println(b) // error
+  println(b2) // error
+  println(b3) // error
+  println(b4) // error
+  //println(b5) // should error (currently accepted!!!)
+  //println(b6) // should error (currently accepted!!!)
+  //println(a222) // should error (currently accepted!!!)

tests/pos-custom-args/captures/paths-complex-consume.scala

@@ -0,0 +1,80 @@
+import language.experimental.captureChecking
+import language.experimental.separationChecking
+import caps.cap
+
+// Create a deeper nesting structure
+class D()
+class C(val d: D^)
+class B(val c: C^)
+class A(consume val b: B^)
+
+// Test 1: Accessing nested fields through a consumed path
+def testNestedFieldsAfterConsume =
+  val d: D^ = D()
+  val c: C^ = C(d)
+  val b: B^ = B(c)
+  val a = A(b)
+
+  // After a consumed b, we should be able to access:
+  println(a.b)       // OK - a owns b
+  println(a.b.c)     // OK - accessing field of consumed b through a
+  println(a.b.c.d)   // OK - deeper nesting through consumed path
+
+// Test 2: Non-trivial prefix accessing a consumed field
+class Container(consume val a: A^):
+  val other: A^ = A(B(C(D())))
+
+class Outer(consume val container: Container^)
+
+def testComplexPrefix =
+  val d1: D^ = D()
+  val c1: C^ = C(d1)
+  val b1: B^ = B(c1)
+  val a1 = A(b1)
+  val container1 = Container(a1)
+  val outer = Outer(container1)
+
+  // Non-trivial prefix: outer.container.a (where 'a' was consumed by container)
+  println(outer.container)            // OK - outer consumed container
+  println(outer.container.a)          // OK - accessing consumed field through prefix
+  println(outer.container.a.b)        // OK - and then its nested fields
+  println(outer.container.a.b.c)      // OK - even deeper
+  println(outer.container.a.b.c.d)    // OK - deepest level
+
+// Test 3: Multiple consume parameters with nested access
+class Multi(consume val b1: B^, consume val b2: B^):
+  val b3: B^ = B(C(D()))
+
+def testMultipleConsume =
+  val b1: B^ = B(C(D()))
+  val b2: B^ = B(C(D()))
+  val multi = Multi(b1, b2)
+
+  // All of these should work:
+  println(multi.b1)           // OK
+  println(multi.b1.c)         // OK - nested field of consumed b1
+  println(multi.b1.c.d)       // OK - deeper nesting
+  println(multi.b2)           // OK
+  println(multi.b2.c)         // OK - nested field of consumed b2
+  println(multi.b2.c.d)       // OK - deeper nesting
+  println(multi.b3.c.d)       // OK - non-consumed field
+
+// Test 4: Consume at multiple levels with complex paths
+class Top(consume val outer: Outer^)
+
+def testMultiLevelConsume =
+  val d2: D^ = D()
+  val c2: C^ = C(d2)
+  val b2: B^ = B(c2)
+  val a2 = A(b2)
+  val container2 = Container(a2)
+  val outer2 = Outer(container2)
+  val top = Top(outer2)
+
+  // Very deep path through multiple consume levels:
+  println(top.outer)                      // OK - top consumed outer
+  println(top.outer.container)            // OK - continue through path
+  println(top.outer.container.a)          // OK - container consumed a
+  println(top.outer.container.a.b)        // OK - a consumed b
+  println(top.outer.container.a.b.c)      // OK - nested field
+  println(top.outer.container.a.b.c.d)    // OK - deepest field

tests/pos-custom-args/captures/paths-deep-consume.scala

@@ -0,0 +1,24 @@
+import language.experimental.captureChecking
+import language.experimental.separationChecking
+import caps.cap
+
+class B
+
+class A(consume val b: B^):
+  val bb: B^ = B()
+
+class C(consume val a: A^):
+  val aa: A^ = A(B())
+
+// Test deep nested access paths
+def testDeepPaths =
+  val b: B^ = B()
+  val a = A(b)
+  val c = C(a)
+
+  // All these should work - accessing through ownership chain
+  println(c.a)       // c owns a
+  println(c.a.b)     // c owns a, a owns b
+  println(c.a.bb)    // c owns a, accessing other field
+  println(c.aa)      // accessing other field of c
+  println(c.aa.b)    // accessing nested field through c.aa

tests/pos-custom-args/captures/paths-nested-consume.scala

@@ -0,0 +1,33 @@
+import language.experimental.captureChecking
+import language.experimental.separationChecking
+import caps.cap
+
+class B
+
+class A(consume val b: B^):
+  val bb: B^ = B()
+
+class C(consume val a: A^):
+  val aa: A^ = A(B())
+
+// Test: After consuming b into a, then consuming a into c,
+// we should be able to access c.a.b (nested field selection)
+def testNestedAccess =
+  val b: B^ = B()
+  val a = A(b)
+  println(a.b)    // OK - a consumed b, accessing through a
+  val c = C(a)
+  println(c.a)    // Should be OK - c consumed a, accessing through c
+  println(c.a.b)  // Should be OK - accessing b through c.a, where c owns a and a owns b
+
+// Test: The deeper path c.a.b should work even though a was consumed
+def testDeepPath =
+  val b: B^ = B()
+  val a = A(b)
+  val c = C(a)
+  // At this point:
+  // - b was consumed by a (so we can't use b directly)
+  // - a was consumed by c (so we can't use a directly)
+  // But we should be able to access:
+  println(c.a.b)  // OK - full path through ownership chain
+  println(c.a.bb) // OK - other field of c.a

tests/pos-custom-args/captures/paths-simple-suffix-consume.scala

@@ -0,0 +1,37 @@
+import language.experimental.captureChecking
+import language.experimental.separationChecking
+import caps.cap
+
+// Create a deep nesting structure for testing suffix paths
+class D
+class C(val d: D^)
+class B(val c: C^)
+class A(consume val b: B^)
+
+// Test 1: Simple suffix paths after consume
+def test1 =
+  val d: D^ = D()
+  val c: C^ = C(d)
+  val b: B^ = B(c)
+  val a = A(b)
+
+  // After 'a' consumes 'b', access nested fields:
+  println(a.b)       // OK - consumed field
+  println(a.b.c)     // OK - suffix: .c after consumed field
+  println(a.b.c.d)   // OK - suffix: .c.d after consumed field
+
+// Test 2: Non-consume wrapper with consumed inner field
+class Holder(val a: A^)  // Note: NOT consume
+
+def test2 =
+  val d: D^ = D()
+  val c: C^ = C(d)
+  val b: B^ = B(c)
+  val a = A(b)
+  val holder = Holder(a)
+
+  // Access through holder.a.b where b was consumed by a:
+  println(holder.a)         // OK - not consumed
+  println(holder.a.b)       // OK - accessing consumed field through prefix
+  println(holder.a.b.c)     // OK - suffix .c
+  println(holder.a.b.c.d)   // OK - suffix .c.d