Add more tests for consume along paths

Author: bracevac

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