Revert "House mutations in local scope"

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

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