Revert "Fix special capture set handling in recheckApply, Step 2"

This reverts commit f1f5a05.

# Conflicts:
#	compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

Author: odersky

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

@@ -554,37 +554,30 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     /** A specialized implementation of the apply rule.
      *
-     *  E |- q: Tq^Cq
-     *  E |- q.f: Ta ->Cf Tr^Cr
-     *  E |- a: Ta
+     *  E |- f: Ra ->Cf Rr^Cr
+     *  E |- a: Ra^Ca
      *  ---------------------
-     *  E |- f(a): Tr^C
+     *  E |- f a: Rr^C
      *
-     *  The implementation picks `C` as `Cq` instead of `Cr`, if
-     *   1. The argument(s) Ta are always pure
-     *   2. `Cq` might subcapture `Cr`.
-     *  TODO: We could generalize this as follows:
-     *
-     *  If the function `f` does not have an `@unboxed` parameter, then
-     *  any unboxing it does would be charged to the environment of the function
-     *  so they have to appear in Cq. So another approximation of the
-     *  result capability set is `Cq u Ca` where `Ca` is the capture set of the
-     *  argument.
-     *  If the function `f` does have an `@unboxed` parameter, then it could in addition
-     *  unbox reach capabilities over its formal parameter. Therefore, the approximation
-     *  would be `Cq u dcs(Ca)` instead.
-     *  If the approximation is known to subcapture the declared result Cr, we pick it.
+     *  The implementation picks as `C` one of `{f, a}` or `Cr`, depending on the
+     *  outcome of a `mightSubcapture` test. It picks `{f, a}` if this might subcapture Cr
+     *  and Cr otherwise.
      */
     protected override
     def recheckApplication(tree: Apply, qualType: Type, funType: MethodType, argTypes: List[Type])(using Context): Type =
       Existential.toCap(super.recheckApplication(tree, qualType, funType, argTypes)) match
         case appType @ CapturingType(appType1, refs)
         if qualType.exists
             && !tree.fun.symbol.isConstructor
-            && argTypes.forall(_.isAlwaysPure)
+            && !qualType.isBoxedCapturing // TODO: This is not strng enough, we also have
+                 // to exclude existentials in function results
+            && !argTypes.exists(_.isBoxedCapturing)
             && qualType.captureSet.mightSubcapture(refs)
+            && argTypes.forall(_.captureSet.mightSubcapture(refs))
         =>
-          appType.derivedCapturingType(appType1, qualType.captureSet)
+          val callCaptures = tree.args.foldLeft(qualType.captureSet): (cs, arg) =>
+              cs ++ arg.tpe.captureSet
+          appType.derivedCapturingType(appType1, callCaptures)
             .showing(i"narrow $tree: $appType, refs = $refs, qual-cs = ${qualType.captureSet} = $result", capt)
         case appType =>
           appType

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

@@ -17,7 +17,7 @@ import scala.annotation.tailrec
 import scala.annotation.unchecked.uncheckedVariance
 import scala.runtime.Statics
 import language.experimental.captureChecking
-import caps.unsafe.unsafeAssumePure
+
 
 /** Iterators are data structures that allow to iterate over a sequence
   * of elements. They have a `hasNext` method for checking
@@ -595,8 +595,7 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
 
     private[this] def nextCur(): Unit = {
       cur = null
-      cur = f(self.next()).iterator.unsafeAssumePure
-        // !!! see explanation in colltest5.CollectionStrawManCC5_1.flatMap why the unsafeAssumePure is needed
+      cur = f(self.next()).iterator
       _hasNext = -1
     }
 

scala2-library-cc/src/scala/collection/immutable/LazyListIterable.scala

@@ -25,7 +25,6 @@ import scala.runtime.Statics
 import language.experimental.captureChecking
 import annotation.unchecked.uncheckedCaptures
 import caps.untrackedCaptures
-import caps.unsafe.unsafeAssumePure
 
 /**  This class implements an immutable linked list. We call it "lazy"
   *  because it computes its elements only when they are needed.
@@ -1042,8 +1041,7 @@ object LazyListIterable extends IterableFactory[LazyListIterable] {
       var itHasNext       = false
       var rest            = restRef           // var rest = restRef.elem
       while (!itHasNext && !rest.isEmpty) {
-        it        = f(rest.head).iterator.unsafeAssumePure
-          // !!! see explanation in colltest5.CollectionStrawManCC5_1.flatMap why the unsafeAssumePure is needed
+        it        = f(rest.head).iterator
         itHasNext = it.hasNext
         if (!itHasNext) {                     // wait to advance `rest` because `it.next()` can throw
           rest    = rest.tail

scala2-library-cc/src/scala/collection/mutable/Buffer.scala

@@ -16,7 +16,6 @@ package mutable
 import scala.annotation.nowarn
 import language.experimental.captureChecking
 import caps.unboxed
-import caps.unsafe.unsafeAssumePure
 
 /** A `Buffer` is a growable and shrinkable `Seq`. */
 trait Buffer[A]
@@ -186,10 +185,7 @@ trait IndexedBuffer[A] extends IndexedSeq[A]
     var i = 0
     val s = size
     val newElems = new Array[(IterableOnce[A]^{f*})](s)
-    while i < s do
-      newElems(i) = f(this(i)).unsafeAssumePure
-        // !!! see explanation in colltest5.CollectionStrawManCC5_1.flatMap why the unsafeAssumePure is needed
-      i += 1
+    while (i < s) { newElems(i) = f(this(i)); i += 1 }
     clear()
     i = 0
     while (i < s) { ++=(newElems(i)); i += 1 }

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

@@ -47,7 +47,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/reaches.scala:64:27 --------------------------------------
 64 |    val f1: File^{id*} = id(f) // error, since now id(f): File^
    |                         ^^^^^
-   |                         Found:    File^
+   |                         Found:    File^{id, f}
    |                         Required: File^{id*}
    |
    | longer explanation available when compiling with `-explain`

tests/pos-custom-args/captures/nested-classes-2.scala

@@ -20,5 +20,5 @@ def test2(x1: (() => Unit), x2: (() => Unit) => Unit) =
   def test3(y1: (() => Unit), y2: (() => Unit) => Unit) =
     val cc1: C1^{y1, y2} = C1(y1, y2)
     val cc2 = cc1.c2(x1, x2)
-    val cc3: cc1.C2^{cc2} = cc2
+    val cc3: cc1.C2^{cc1, x1, x2} = cc2
 

tests/run-custom-args/captures/colltest5/CollectionStrawManCC5_1.scala

@@ -5,7 +5,6 @@ import Predef.{augmentString as _, wrapString as _, *}
 import scala.reflect.ClassTag
 import annotation.unchecked.{uncheckedVariance, uncheckedCaptures}
 import annotation.tailrec
-import caps.unsafe.unsafeAssumePure
 
 /** A strawman architecture for new collections. It contains some
  *  example collection classes and methods with the intent to expose
@@ -556,16 +555,7 @@ object CollectionStrawMan5 {
       private var myCurrent: Iterator[B]^{this, f} = Iterator.empty
       private def current = {
         while (!myCurrent.hasNext && self.hasNext)
-          myCurrent = f(self.next()).iterator.unsafeAssumePure
-            // !!! This is unsafe since the iterator's result could return a capability
-            // depending on the argument self.next() of type A. To exclude that we'd have
-            // to define f to be of type EX c. A ->{c} IterableOnce[B]^{c}, i.e. `c` may
-            // not depend on A. But to get there we have to
-            //  - improve the way we express existentials using `^`
-            //  - rework the recheckApplication code to cater for this. Right now
-            //    we cannot do anything since `A` is not always pure. But if we took
-            //    the existential scope of the result into account, this could provide
-            //    a solution.
+          myCurrent = f(self.next()).iterator
         myCurrent
       }
       def hasNext = current.hasNext