Fix compute overlap logic for consumes

 - Make it peak-based instead of footprint-based
 - Don't flag rd/rd conflicts between consumed and re-used

Author: odersky

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

@@ -97,6 +97,7 @@ object SepCheck:
     var refs: Array[CaptureRef] = new Array(4)
     var locs: Array[SrcPos] = new Array(4)
     var size = 0
+    var peaks: Refs = emptyRefs
 
     private def double[T <: AnyRef : ClassTag](xs: Array[T]): Array[T] =
       val xs1 = new Array[T](xs.length * 2)
@@ -114,31 +115,44 @@ object SepCheck:
       while i < size && (refs(i) ne ref) do i += 1
       if i < size then locs(i) else null
 
+    def clashing(ref: CaptureRef)(using Context): SrcPos | Null =
+      val refPeaks = ref.peaks
+      if !peaks.sharedWith(refPeaks).isEmpty then
+        var i = 0
+        while i < size && refs(i).peaks.sharedWith(refPeaks).isEmpty do
+          i += 1
+        assert(i < size)
+        locs(i)
+      else null
+
     /** If `ref` is not yet in the set, add it with given source position */
-    def put(ref: CaptureRef, loc: SrcPos): Unit =
+    def put(ref: CaptureRef, loc: SrcPos)(using Context): Unit =
       if get(ref) == null then
         ensureCapacity(1)
         refs(size) = ref
         locs(size) = loc
         size += 1
+        peaks = peaks ++ ref.peaks
 
     /** Add all references with their associated positions from `that` which
      *  are not yet in the set.
      */
-    def ++= (that: ConsumedSet): Unit =
+    def ++= (that: ConsumedSet)(using Context): Unit =
       for i <- 0 until that.size do put(that.refs(i), that.locs(i))
 
     /** Run `op` and return any new references it created in a separate `ConsumedSet`.
      *  The current mutable set is reset to its state before `op` was run.
      */
     def segment(op: => Unit): ConsumedSet =
       val start = size
+      val savedPeaks = peaks
       try
         op
         if size == start then EmptyConsumedSet
         else ConstConsumedSet(refs.slice(start, size), locs.slice(start, size))
       finally
         size = start
+        peaks = savedPeaks
   end MutConsumedSet
 
   val EmptyConsumedSet = ConstConsumedSet(Array(), Array())
@@ -265,6 +279,9 @@ object SepCheck:
 
   end extension
 
+  extension (ref: CaptureRef)
+    def peaks(using Context): Refs = SimpleIdentitySet(ref).peaks
+
 class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
   import checker.*
   import SepCheck.*
@@ -553,7 +570,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
             sepUseError(tree, null, used, defsShadow)
 
       for ref <- used do
-        val pos = consumed.get(ref.stripReadOnly)
+        val pos = consumed.clashing(ref)
         if pos != null then consumeError(ref, pos, tree.srcPos)
   end checkUse
 
@@ -632,7 +649,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
       case _: TypeRole.Argument | _: TypeRole.Qualifier =>
         for ref <- refsToCheck do
           if !ref.derivesFromSharedCapability then
-            consumed.put(ref.stripReadOnly, pos)
+            consumed.put(ref, pos)
       case _ =>
   end checkConsumedRefs
 

tests/neg-custom-args/captures/sep-consume.check

@@ -4,31 +4,25 @@
    |  Separation failure: Illegal access to (x : Ref^), which was passed to a
    |  @consume parameter or was used as a prefix to a @consume method on line 18
    |  and therefore is no longer available.
--- Error: tests/neg-custom-args/captures/sep-consume.scala:20:2 --------------------------------------------------------
-20 |  x.get      // error
-   |  ^
-   |  Separation failure: Illegal access to x.rd, which was passed to a
-   |  @consume parameter or was used as a prefix to a @consume method on line 18
-   |  and therefore is no longer available.
 -- Error: tests/neg-custom-args/captures/sep-consume.scala:21:16 -------------------------------------------------------
 21 |  par(rx, () => x.put(42))  // error
    |                ^
    |                Separation failure: Illegal access to (x : Ref^), which was passed to a
    |                @consume parameter or was used as a prefix to a @consume method on line 18
    |                and therefore is no longer available.
--- Error: tests/neg-custom-args/captures/sep-consume.scala:22:16 -------------------------------------------------------
-22 |  par(rx, () => x.get)  // error
-   |                ^
-   |                Separation failure: Illegal access to x.rd, which was passed to a
-   |                @consume parameter or was used as a prefix to a @consume method on line 18
-   |                and therefore is no longer available.
 -- Error: tests/neg-custom-args/captures/sep-consume.scala:26:16 -------------------------------------------------------
 26 |  def foo = bad(f) // error
    |                ^
    | Separation failure: argument to @consume parameter with type (f : () ->{x.rd} Unit) refers to non-local value f
 -- Error: tests/neg-custom-args/captures/sep-consume.scala:34:12 -------------------------------------------------------
-34 |  println(p.fst.get) // errorSep
+34 |  println(p.fst.get) // error
    |          ^^^^^
    |          Separation failure: Illegal access to p.fst*, which was passed to a
    |          @consume parameter or was used as a prefix to a @consume method on line 33
    |          and therefore is no longer available.
+-- Error: tests/neg-custom-args/captures/sep-consume.scala:40:12 -------------------------------------------------------
+40 |  println(p.fst.get) // error
+   |          ^^^^^
+   |          Separation failure: Illegal access to p.fst*, which was passed to a
+   |          @consume parameter or was used as a prefix to a @consume method on line 39
+   |          and therefore is no longer available.

tests/neg-custom-args/captures/sep-consume.scala

@@ -17,9 +17,9 @@ def test2(@consume x: Ref^): Unit =
   val f: () ->{x.rd} Unit = () => x.get
   val rx: () => Unit = bad(f)  // hides x.rd in the resulting `cap`
   x.put(42)  // error
-  x.get      // error
+  x.get      // ok rd/rd
   par(rx, () => x.put(42))  // error
-  par(rx, () => x.get)  // error
+  par(rx, () => x.get)  // ok rd/rd
 
 def test3(@consume x: Ref^): Unit =
   val f: () ->{x.rd} Unit = () => x.get
@@ -31,11 +31,11 @@ def test4(@consume @use p: Pair[Ref^, Ref^]): Unit =
   val x: Ref^{p.fst*} = p.fst
   val y: Ref^{p.snd*} = p.snd
   badp(Pair(x, y))
-  println(p.fst.get) // errorSep
+  println(p.fst.get) // error
 
 def badp(@consume p: Pair[Ref^, Ref^]): Unit = ()
 
 def test5(@consume @use p: Pair[Ref^, Ref^]): Unit =
   badp(p) // ok
-  println(p.fst.get) // ok, but should be error
+  println(p.fst.get) // error