House mutations in local scope

phausler · phausler · commit 3faaf3c63749 · 2021-01-12T10:58:53.000-08:00
diff --git a/stdlib/public/Concurrency/AsyncCompactMapSequence.swift b/stdlib/public/Concurrency/AsyncCompactMapSequence.swift
@@ -37,7 +37,12 @@ public struct AsyncCompactMapSequence<Upstream, ElementOfResult>: AsyncSequence
     
     public mutating func next() async rethrows -> ElementOfResult? {
       while true {
-        guard let item = try await upstreamIterator?.next() else {
+        guard var upstreamIterator = self.upstreamIterator else {
+          return nil
+        }
+        defer { self.upstreamIterator = upstreamIterator }
+
+        guard let item = try await upstreamIterator.next() else {
           return nil
         }
         if let transformed = await transform(item) {
@@ -80,16 +85,22 @@ public struct AsyncTryCompactMapSequence<Upstream, ElementOfResult>: AsyncSequen
     
     public mutating func next() async throws -> ElementOfResult? {
       while true {
-        guard let item = try await upstreamIterator?.next() else {
+        guard var upstreamIterator = self.upstreamIterator else {
+          return nil
+        }
+
+        guard let item = try await upstreamIterator.next() else {
           return nil
         }
         do {
           if let transformed = try await transform(item) {
+            self.upstreamIterator = upstreamIterator
             return transformed
           }
+          self.upstreamIterator = upstreamIterator
         } catch {
-          upstreamIterator?.cancel()
-          upstreamIterator = nil
+          upstreamIterator.cancel()
+          self.upstreamIterator = nil
           throw error
         }
       }
diff --git a/stdlib/public/Concurrency/AsyncDropWhileSequence.swift b/stdlib/public/Concurrency/AsyncDropWhileSequence.swift
@@ -37,7 +37,12 @@ public struct AsyncDropWhileSequence<Upstream>: AsyncSequence where Upstream: As
     
     public mutating func next() async rethrows -> Upstream.Element? {
       while true {
-        guard let item = try await upstreamIterator?.next() else {
+        guard var upstreamIterator = self.upstreamIterator else {
+          return nil
+        }
+        defer { self.upstreamIterator = upstreamIterator }
+
+        guard let item = try await upstreamIterator.next() else {
           return nil
         }
         if let predicate = self.predicate {
@@ -85,21 +90,29 @@ public struct AsyncTryDropWhileSequence<Upstream>: AsyncSequence where Upstream:
     
     public mutating func next() async throws -> Upstream.Element? {
       while true {
-        guard let item = try await upstreamIterator?.next() else {
+        guard var upstreamIterator = self.upstreamIterator else {
+          return nil
+        }
+
+        guard let item = try await upstreamIterator.next() else {
+          self.upstreamIterator = upstreamIterator
           return nil
         }
         if let predicate = self.predicate {
           do {
             if !(try await predicate(item)) {
               self.predicate = nil
+              self.upstreamIterator = upstreamIterator
               return item
             }
+            self.upstreamIterator = upstreamIterator
           } catch {
-            upstreamIterator?.cancel()
-            upstreamIterator = nil
+            upstreamIterator.cancel()
+            self.upstreamIterator = nil
             throw error
           }
         } else {
+          self.upstreamIterator = upstreamIterator
           return item
         }
       }
diff --git a/stdlib/public/Concurrency/AsyncFilterSequence.swift b/stdlib/public/Concurrency/AsyncFilterSequence.swift
@@ -41,14 +41,20 @@ public struct AsyncFilterSequence<Upstream>: AsyncSequence where Upstream: Async
     }
     
     public mutating func next() async rethrows -> Upstream.Element? {
-      guard let item = try await upstreamIterator?.next() else {
+      guard var upstreamIterator = self.upstreamIterator else {
+        return nil
+      }
+
+      guard let item = try await upstreamIterator.next() else {
+        self.upstreamIterator = upstreamIterator
         return nil
       }
       guard await predicate(item) else {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
-      return nil
+        upstreamIterator.cancel()
+        self.upstreamIterator = nil
+        return nil
       }
+      self.upstreamIterator = upstreamIterator
       return item
     }
     
@@ -87,14 +93,19 @@ public struct AsyncTryFilterSequence<Upstream>: AsyncSequence where Upstream: As
     }
     
     public mutating func next() async throws -> Upstream.Element? {
-      guard let item = try await upstreamIterator?.next() else {
+      guard var upstreamIterator = self.upstreamIterator else {
+        return nil
+      }
+
+      guard let item = try await upstreamIterator.next() else {
         return nil
       }
       guard try await predicate(item) else {
-      upstreamIterator?.cancel()
-      upstreamIterator = nil
-      return nil
+        upstreamIterator.cancel()
+        self.upstreamIterator = nil
+        return nil
       }
+      self.upstreamIterator = upstreamIterator
       return item
     }
     
diff --git a/stdlib/public/Concurrency/AsyncFlatMapSequence.swift b/stdlib/public/Concurrency/AsyncFlatMapSequence.swift
@@ -35,17 +35,34 @@ public struct AsyncFlatMapSequence<Upstream, SegmentOfResult: AsyncSequence>: As
       self.upstreamIterator = upstreamIterator
       self.transform = transform
     }
+
+    mutating func nextUpstream() async rethrows -> SegmentOfResult.Element? {
+      guard var upstreamIterator = self.upstreamIterator else {
+        return nil
+      }
+
+      guard let item = try await upstreamIterator.next() else {
+        self.upstreamIterator = upstreamIterator
+        return nil
+      }
+      let segment = await transform(item)
+      var currentIterator = segment.makeAsyncIterator()
+      self.currentIterator = currentIterator
+      self.upstreamIterator = upstreamIterator
+      return try await currentIterator.next()
+    }
     
     public mutating func next() async rethrows -> SegmentOfResult.Element? {
-      if let item = try await currentIterator?.next() {
+      guard var currentIterator = self.currentIterator else {
+        return try await nextUpstream()
+      }
+
+      if let item = try await currentIterator.next() {
+        self.currentIterator = currentIterator
         return item
       } else {
-        guard let item = try await upstreamIterator?.next() else {
-          return nil
-        }
-        let segment = await transform(item)
-        currentIterator = segment.makeAsyncIterator()
-        return try await currentIterator?.next()
+        self.currentIterator = currentIterator
+        return try await nextUpstream()
       }
     }
     
@@ -83,17 +100,34 @@ public struct AsyncTryFlatMapSequence<Upstream, SegmentOfResult: AsyncSequence>:
       self.upstreamIterator = upstreamIterator
       self.transform = transform
     }
+
+    mutating func nextUpstream() async throws -> SegmentOfResult.Element? {
+      guard var upstreamIterator = self.upstreamIterator else {
+        return nil
+      }
+
+      guard let item = try await upstreamIterator.next() else {
+        self.upstreamIterator = upstreamIterator
+        return nil
+      }
+      let segment = try await transform(item)
+      var currentIterator = segment.makeAsyncIterator()
+      self.currentIterator = currentIterator
+      self.upstreamIterator = upstreamIterator
+      return try await currentIterator.next()
+    }
     
     public mutating func next() async throws -> SegmentOfResult.Element? {
-      if let item = try await currentIterator?.next() {
+      guard var currentIterator = self.currentIterator else {
+        return try await nextUpstream()
+      }
+
+      if let item = try await currentIterator.next() {
+        self.currentIterator = currentIterator
         return item
       } else {
-        guard let item = try await upstreamIterator?.next() else {
-          return nil
-        }
-        let segment = try await transform(item)
-        currentIterator = segment.makeAsyncIterator()
-        return try await currentIterator?.next()
+        self.currentIterator = currentIterator
+        return try await nextUpstream()
       }
     }
     
diff --git a/stdlib/public/Concurrency/AsyncMapSequence.swift b/stdlib/public/Concurrency/AsyncMapSequence.swift
@@ -38,7 +38,12 @@ public struct AsyncMapSequence<Upstream, Transformed>: AsyncSequence where Upstr
     }
     
     public mutating func next() async rethrows -> Transformed? {
-      guard let item = try await upstreamIterator?.next() else {
+      guard var upstreamIterator = self.upstreamIterator else {
+        return nil
+      }
+      defer { self.upstreamIterator = upstreamIterator }
+
+      guard let item = try await upstreamIterator.next() else {
         return nil
       }
       return await transform(item)
@@ -79,7 +84,12 @@ public struct AsyncTryMapSequence<Upstream, Transformed>: AsyncSequence where Up
     }
     
     public mutating func next() async throws -> Transformed? {
-      guard let item = try await upstreamIterator?.next() else {
+      guard var upstreamIterator = self.upstreamIterator else {
+        return nil
+      }
+      defer { self.upstreamIterator = upstreamIterator }
+      
+      guard let item = try await upstreamIterator.next() else {
         return nil
       }
       return try await transform(item)
diff --git a/stdlib/public/Concurrency/AsyncPrefixWhileSequence.swift b/stdlib/public/Concurrency/AsyncPrefixWhileSequence.swift
@@ -36,14 +36,19 @@ public struct AsyncPrefixWhileSequence<Upstream>: AsyncSequence where Upstream:
     }
     
     public mutating func next() async rethrows -> Element? {
-      guard let item = try await upstreamIterator?.next() else {
+      guard var upstreamIterator = self.upstreamIterator else {
+        return nil
+      }
+
+      guard let item = try await upstreamIterator.next() else {
         return nil
       }
       guard await predicate(item) else {
-        upstreamIterator?.cancel()
-        upstreamIterator = nil
+        upstreamIterator.cancel()
+        self.upstreamIterator = nil
         return nil
       }
+      self.upstreamIterator = upstreamIterator
       return item
     }
     
@@ -80,14 +85,20 @@ public struct AsyncTryPrefixWhileSequence<Upstream>: AsyncSequence where Upstrea
     }
     
     public mutating func next() async throws -> Element? {
-      guard let item = try await upstreamIterator?.next() else {
+      guard var upstreamIterator = self.upstreamIterator else {
+        return nil
+      }
+
+      guard let item = try await upstreamIterator.next() else {
+        self.upstreamIterator = upstreamIterator
         return nil
       }
       guard try await predicate(item) else {
-        upstreamIterator?.cancel()
-        upstreamIterator = nil
+        upstreamIterator.cancel()
+        self.upstreamIterator = nil
         return nil
       }
+      self.upstreamIterator = upstreamIterator
       return item
     }
     

Original file line number	Diff line number	Diff line change
`@@ -41,14 +41,20 @@ public struct AsyncFilterSequence<Upstream>: AsyncSequence where Upstream: Async`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`public mutating func next() async rethrows -> Upstream.Element? {`
`44`		`- guard let item = try await upstreamIterator?.next() else {`
	`44`	`+ guard var upstreamIterator = self.upstreamIterator else {`
	`45`	`+ return nil`
	`46`	`+ }`
	`47`	`+`
	`48`	`+ guard let item = try await upstreamIterator.next() else {`
	`49`	`+ self.upstreamIterator = upstreamIterator`
`45`	`50`	`return nil`
`46`	`51`	`}`
`47`	`52`	`guard await predicate(item) else {`
`48`		`- upstreamIterator?.cancel()`
`49`		`- upstreamIterator = nil`
`50`		`- return nil`
	`53`	`+ upstreamIterator.cancel()`
	`54`	`+ self.upstreamIterator = nil`
	`55`	`+ return nil`
`51`	`56`	`}`
	`57`	`+ self.upstreamIterator = upstreamIterator`
`52`	`58`	`return item`
`53`	`59`	`}`
`54`	`60`
`@@ -87,14 +93,19 @@ public struct AsyncTryFilterSequence<Upstream>: AsyncSequence where Upstream: As`
`87`	`93`	`}`
`88`	`94`
`89`	`95`	`public mutating func next() async throws -> Upstream.Element? {`
`90`		`- guard let item = try await upstreamIterator?.next() else {`
	`96`	`+ guard var upstreamIterator = self.upstreamIterator else {`
	`97`	`+ return nil`
	`98`	`+ }`
	`99`	`+`
	`100`	`+ guard let item = try await upstreamIterator.next() else {`
`91`	`101`	`return nil`
`92`	`102`	`}`
`93`	`103`	`guard try await predicate(item) else {`
`94`		`- upstreamIterator?.cancel()`
`95`		`- upstreamIterator = nil`
`96`		`- return nil`
	`104`	`+ upstreamIterator.cancel()`
	`105`	`+ self.upstreamIterator = nil`
	`106`	`+ return nil`
`97`	`107`	`}`
	`108`	`+ self.upstreamIterator = upstreamIterator`
`98`	`109`	`return item`
`99`	`110`	`}`
`100`	`111`
Original file line number	Diff line number	Diff line change
`@@ -36,14 +36,19 @@ public struct AsyncPrefixWhileSequence<Upstream>: AsyncSequence where Upstream:`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`public mutating func next() async rethrows -> Element? {`
`39`		`- guard let item = try await upstreamIterator?.next() else {`
	`39`	`+ guard var upstreamIterator = self.upstreamIterator else {`
	`40`	`+ return nil`
	`41`	`+ }`
	`42`	`+`
	`43`	`+ guard let item = try await upstreamIterator.next() else {`
`40`	`44`	`return nil`
`41`	`45`	`}`
`42`	`46`	`guard await predicate(item) else {`
`43`		`- upstreamIterator?.cancel()`
`44`		`- upstreamIterator = nil`
	`47`	`+ upstreamIterator.cancel()`
	`48`	`+ self.upstreamIterator = nil`
`45`	`49`	`return nil`
`46`	`50`	`}`
	`51`	`+ self.upstreamIterator = upstreamIterator`
`47`	`52`	`return item`
`48`	`53`	`}`
`49`	`54`
`@@ -80,14 +85,20 @@ public struct AsyncTryPrefixWhileSequence<Upstream>: AsyncSequence where Upstrea`
`80`	`85`	`}`
`81`	`86`
`82`	`87`	`public mutating func next() async throws -> Element? {`
`83`		`- guard let item = try await upstreamIterator?.next() else {`
	`88`	`+ guard var upstreamIterator = self.upstreamIterator else {`
	`89`	`+ return nil`
	`90`	`+ }`
	`91`	`+`
	`92`	`+ guard let item = try await upstreamIterator.next() else {`
	`93`	`+ self.upstreamIterator = upstreamIterator`
`84`	`94`	`return nil`
`85`	`95`	`}`
`86`	`96`	`guard try await predicate(item) else {`
`87`		`- upstreamIterator?.cancel()`
`88`		`- upstreamIterator = nil`
	`97`	`+ upstreamIterator.cancel()`
	`98`	`+ self.upstreamIterator = nil`
`89`	`99`	`return nil`
`90`	`100`	`}`
	`101`	`+ self.upstreamIterator = upstreamIterator`
`91`	`102`	`return item`
`92`	`103`	`}`
`93`	`104`