Merge pull request #71524 from DougGregor/async-iterator-next-rename

Rename `AsyncIteratorProtocol.next(_:)` to `next(isolation:)`

Author: DougGregor

include/swift/AST/KnownIdentifiers.def

@@ -118,6 +118,7 @@ IDENTIFIER(makeIterator)
 IDENTIFIER(makeAsyncIterator)
 IDENTIFIER(nestedContainer)
 IDENTIFIER(isEmpty)
+IDENTIFIER(isolation)
 IDENTIFIER(Iterator)
 IDENTIFIER(AsyncIterator)
 IDENTIFIER(load)

lib/Sema/CSGen.cpp

@@ -4604,12 +4604,15 @@ generateForEachStmtConstraints(ConstraintSystem &cs, DeclContext *dc,
         TypeChecker::getForEachIteratorNextFunction(dc, stmt->getForLoc(), isAsync);
     Identifier nextId = nextFn ? nextFn->getName().getBaseIdentifier()
                                : ctx.Id_next;
+    TinyPtrVector<Identifier> labels;
+    if (nextFn && nextFn->getParameters()->size() == 1)
+      labels.push_back(ctx.Id_isolation);
     auto *nextRef = UnresolvedDotExpr::createImplicit(
         ctx,
         new (ctx) DeclRefExpr(makeIteratorVar, DeclNameLoc(stmt->getForLoc()),
                               /*Implicit=*/true),
-        nextId, /*labels=*/ArrayRef<Identifier>());
-    nextRef->setFunctionRefKind(FunctionRefKind::SingleApply);
+        nextId, labels);
+    nextRef->setFunctionRefKind(FunctionRefKind::Compound);
 
     ArgumentList *nextArgs;
     if (nextFn && nextFn->getParameters()->size() == 1) {

lib/Sema/CSSimplify.cpp

@@ -10804,7 +10804,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
       // Handle `next` reference.
       if (getContextualTypePurpose(baseExpr) == CTP_ForEachSequence &&
           (isRefTo(memberRef, ctx.Id_next, /*labels=*/{}) ||
-           isRefTo(memberRef, ctx.Id_next, /*labels=*/{StringRef()}))) {
+           isRefTo(memberRef, ctx.Id_next, /*labels=*/{ "isolation" }))) {
         auto *iteratorProto = cast<ProtocolDecl>(
             getContextualType(baseExpr, /*forConstraint=*/false)
                 ->getAnyNominal());

stdlib/public/Concurrency/AsyncCompactMapSequence.swift

@@ -140,9 +140,9 @@ extension AsyncCompactMapSequence: AsyncSequence {
     /// that transforms to a non-`nil` value.
     @available(SwiftStdlib 5.11, *)
     @inlinable
-    public mutating func next(_ actor: isolated (any Actor)?) async throws(Failure) -> ElementOfResult? {
+    public mutating func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> ElementOfResult? {
       while true {
-        guard let element = try await baseIterator.next(actor) else {
+        guard let element = try await baseIterator.next(isolation: actor) else {
           return nil
         }
 

stdlib/public/Concurrency/AsyncDropFirstSequence.swift

@@ -118,24 +118,24 @@ extension AsyncDropFirstSequence: AsyncSequence {
     /// Produces the next element in the drop-first sequence.
     ///
     /// Until reaching the number of elements to drop, this iterator calls
-    /// `next(_:)` on its base iterator and discards the result. If the
+    /// `next(isolation:)` on its base iterator and discards the result. If the
     /// base iterator returns `nil`, indicating the end of the sequence, this
     /// iterator returns `nil`. After reaching the number of elements to drop,
-    /// this iterator passes along the result of calling `next(_:)` on the
-    /// base iterator.
+    /// this iterator passes along the result of calling `next(isolation:)` on
+    /// the base iterator.
     @available(SwiftStdlib 5.11, *)
     @inlinable
-    public mutating func next(_ actor: isolated (any Actor)?) async throws(Failure) -> Base.Element? {
+    public mutating func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> Base.Element? {
       var remainingToDrop = count
       while remainingToDrop > 0 {
-        guard try await baseIterator.next(actor) != nil else {
+        guard try await baseIterator.next(isolation: actor) != nil else {
           count = 0
           return nil
         }
         remainingToDrop -= 1
       }
       count = 0
-      return try await baseIterator.next(actor)
+      return try await baseIterator.next(isolation: actor)
     }
   }
 

stdlib/public/Concurrency/AsyncDropWhileSequence.swift

@@ -129,26 +129,26 @@ extension AsyncDropWhileSequence: AsyncSequence {
 
     /// Produces the next element in the drop-while sequence.
     ///
-    /// This iterator calls `next(_:)` on its base iterator and evaluates
-    /// the result with the `predicate` closure. As long as the predicate
-    /// returns `true`, this method returns `nil`. After the predicate returns
-    /// `false`, for a value received from the base iterator, this method
-    /// returns that value. After that, the iterator returns values received
-    /// from its base iterator as-is, and never executes the predicate closure
-    /// again.
+    /// This iterator calls `next(isolation:)` on its base iterator and
+    /// evaluates the result with the `predicate` closure. As long as the
+    /// predicate returns `true`, this method returns `nil`. After the predicate
+    /// returns `false`, for a value received from the base iterator, this
+    /// method returns that value. After that, the iterator returns values
+    /// received from its base iterator as-is, and never executes the predicate
+    /// closure again.
     @available(SwiftStdlib 5.11, *)
     @inlinable
-    public mutating func next(_ actor: isolated (any Actor)?) async throws(Failure) -> Base.Element? {
+    public mutating func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> Base.Element? {
       while let predicate = self.predicate {
-        guard let element = try await baseIterator.next(actor) else {
+        guard let element = try await baseIterator.next(isolation: actor) else {
           return nil
         }
         if await predicate(element) == false {
           self.predicate = nil
           return element
         }
       }
-      return try await baseIterator.next(actor)
+      return try await baseIterator.next(isolation: actor)
     }
   }
 

stdlib/public/Concurrency/AsyncFilterSequence.swift

@@ -116,16 +116,16 @@ extension AsyncFilterSequence: AsyncSequence {
 
     /// Produces the next element in the filter sequence.
     ///
-    /// This iterator calls `next()` on its base iterator; if this call
-    /// returns `nil`, `next()` returns nil. Otherwise, `next()`
-    /// evaluates the result with the `predicate` closure. If the closure
-    /// returns `true`, `next()` returns the received element; otherwise
-    /// it awaits the next element from the base iterator.
+    /// This iterator calls `next(isolation:)` on its base iterator; if this
+    /// call returns `nil`, `next(isolation:)` returns nil. Otherwise,
+    /// `next(isolation:)` evaluates the result with the `predicate` closure. If
+    /// the closure returns `true`, `next(isolation:)` returns the received
+    /// element; otherwise it awaits the next element from the base iterator.
     @available(SwiftStdlib 5.11, *)
     @inlinable
-    public mutating func next(_ actor: isolated (any Actor)?) async throws(Failure) -> Base.Element? {
+    public mutating func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> Base.Element? {
       while true {
-        guard let element = try await baseIterator.next(actor) else {
+        guard let element = try await baseIterator.next(isolation: actor) else {
           return nil
         }
         if await isIncluded(element) {

stdlib/public/Concurrency/AsyncFlatMapSequence.swift

@@ -267,20 +267,21 @@ extension AsyncFlatMapSequence: AsyncSequence {
 
     /// Produces the next element in the flat map sequence.
     ///
-    /// This iterator calls `next()` on its base iterator; if this call
-    /// returns `nil`, `next()` returns `nil`. Otherwise, `next()`
-    /// calls the transforming closure on the received element, takes the
-    /// resulting asynchronous sequence, and creates an asynchronous iterator
-    /// from it.  `next()` then consumes values from this iterator until
-    /// it terminates.  At this point, `next()` is ready to receive the
-    /// next value from the base sequence.
+    /// This iterator calls `next(isolation:)` on its base iterator; if this
+    /// call returns `nil`, `next(isolation:)` returns `nil`. Otherwise,
+    /// `next(isolation:)` calls the transforming closure on the received
+    /// element, takes the resulting asynchronous sequence, and creates an
+    /// asynchronous iterator from it.  `next(isolation:)` then consumes values
+    /// from this iterator until it terminates.  At this point,
+    /// `next(isolation:)` is ready to receive the next value from the base
+    /// sequence.
     @available(SwiftStdlib 5.11, *)
     @inlinable
-    public mutating func next(_ actor: isolated (any Actor)?) async throws(Failure) -> SegmentOfResult.Element? {
+    public mutating func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> SegmentOfResult.Element? {
       while !finished {
         if var iterator = currentIterator {
           do {
-            let optElement = try await iterator.next(actor)
+            let optElement = try await iterator.next(isolation: actor)
             guard let element = optElement else {
               currentIterator = nil
               continue
@@ -293,15 +294,15 @@ extension AsyncFlatMapSequence: AsyncSequence {
             throw error as! Failure
           }
         } else {
-          let optItem = try await baseIterator.next(actor)
+          let optItem = try await baseIterator.next(isolation: actor)
           guard let item = optItem else {
             finished = true
             return nil
           }
           do {
             let segment = await transform(item)
             var iterator = segment.makeAsyncIterator()
-            let optElement = try await iterator.next(actor)  
+            let optElement = try await iterator.next(isolation: actor)  
             guard let element = optElement else {
               currentIterator = nil
               continue

stdlib/public/Concurrency/AsyncIteratorProtocol.swift

@@ -106,7 +106,7 @@ public protocol AsyncIteratorProtocol<Element, Failure> {
   /// - Returns: The next element, if it exists, or `nil` to signal the end of
   ///   the sequence.
   @available(SwiftStdlib 5.11, *)
-  mutating func next(_ actor: isolated (any Actor)?) async throws(Failure) -> Element?
+  mutating func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> Element?
 }
 
 @available(SwiftStdlib 5.1, *)
@@ -115,7 +115,7 @@ extension AsyncIteratorProtocol {
   /// required to maintain backward compatibility with existing async iterators.
   @available(SwiftStdlib 5.11, *)
   @inlinable
-  public mutating func next(_ actor: isolated (any Actor)?) async throws(Failure) -> Element? {
+  public mutating func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> Element? {
     do {
       return try await next()
     } catch {

stdlib/public/Concurrency/AsyncMapSequence.swift

@@ -120,13 +120,14 @@ extension AsyncMapSequence: AsyncSequence {
 
     /// Produces the next element in the map sequence.
     ///
-    /// This iterator calls `next()` on its base iterator; if this call returns
-    /// `nil`, `next()` returns `nil`. Otherwise, `next()` returns the result of
-    /// calling the transforming closure on the received element.
+    /// This iterator calls `next(isolation:)` on its base iterator; if this
+    /// call returns `nil`, `next(isolation:)` returns `nil`. Otherwise,
+    /// `next(isolation:)` returns the result of calling the transforming
+    /// closure on the received element.
     @available(SwiftStdlib 5.11, *)
     @inlinable
-    public mutating func next(_ actor: isolated (any Actor)?) async throws(Failure) -> Transformed? {
-      guard let element = try await baseIterator.next(actor) else {
+    public mutating func next(isolation actor: isolated (any Actor)?) async throws(Failure) -> Transformed? {
+      guard let element = try await baseIterator.next(isolation: actor) else {
         return nil
       }
       return await transform(element)