stdlib: always check that IteratorProtocol.next() repeatedly returns nil

This is required by SE-0052.

Author: gribozavr

stdlib/private/StdlibCollectionUnittest/CheckCollectionInstance.swift.gyb

@@ -23,7 +23,6 @@ public struct CollectionMisuseResiliencyChecks {
     case trap
   }
 
-  public var callNextOnExhaustedGenerator: Bool = true
   public var creatingOutOfBoundsIndicesBehavior: FailureKind = .trap
   public var subscriptOnOutOfBoundsIndicesBehavior: FailureKind = .trap
   public var subscriptRangeOnOutOfBoundsRangesBehavior: FailureKind = .trap
@@ -34,7 +33,6 @@ public struct CollectionMisuseResiliencyChecks {
 
   public static var none: CollectionMisuseResiliencyChecks {
     return CollectionMisuseResiliencyChecks(
-      callNextOnExhaustedGenerator: false,
       creatingOutOfBoundsIndicesBehavior: .none,
       subscriptOnOutOfBoundsIndicesBehavior: .none,
       subscriptRangeOnOutOfBoundsRangesBehavior: .none)

stdlib/private/StdlibCollectionUnittest/CheckSequenceInstance.swift.gyb

@@ -43,12 +43,10 @@ public func checkIterator<
   expectEqualSequence(
     expected, actual, ${trace}, sameValue: sameValue)
 
-  if resiliencyChecks.callNextOnExhaustedGenerator {
-    // Having returned `.None` once, a `IteratorProtocol` should not generate more
-    // elements.
-    for _ in 0..<10 {
-      expectEmpty(mutableGen.next(), ${trace})
-    }
+  // Having returned `.None` once, a `IteratorProtocol` should not generate
+  // more elements.
+  for _ in 0..<10 {
+    expectEmpty(mutableGen.next(), ${trace})
   }
 }
 

validation-test/stdlib/Collection/LazyFilterCollection.swift.gyb

@@ -63,65 +63,44 @@ CollectionTests.add${traversal}${kind}Tests(
 % for (traversal, kind) in variations:
 CollectionTests.test("LazyFilterCollection instances (${traversal}${kind})") {
   do {
-    // MinimalIterator will error if next() is called after exhaustion
-    var resiliency = CollectionMisuseResiliencyChecks.all
-    resiliency.callNextOnExhaustedGenerator = false
-
     let expected : [String] = []
     let base = ["apple", "orange", "banana", "grapefruit", "lychee"]
 % if kind == 'Sequence':
     checkSequence(
       expected,
-      MinimalSequence(elements: base).lazy.filter { _ in return false },
-      resiliencyChecks: resiliency
-    )
+      MinimalSequence(elements: base).lazy.filter { _ in return false })
 % elif traversal == '' and kind == 'Collection':
     checkForwardCollection(
       expected,
       MinimalCollection(elements: base).lazy.filter { _ in return false },
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % else:
     check${traversal}${kind}(
       expected,
       Minimal${traversal}${kind}(elements: base).lazy.filter { _ in return false },
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % end
   }
   do {
-    var resiliency = CollectionMisuseResiliencyChecks.all
-    resiliency.callNextOnExhaustedGenerator = false
-
     let expected = ["apple", "orange", "banana", "grapefruit", "lychee"]
     let base = ["apple", "orange", "banana", "grapefruit", "lychee"]
 % if kind == 'Sequence':
     checkSequence(
       expected,
-      MinimalSequence(elements: base).lazy.filter { _ in return true },
-      resiliencyChecks: resiliency
-    )
+      MinimalSequence(elements: base).lazy.filter { _ in return true })
 % elif traversal == '' and kind == 'Collection':
     checkForwardCollection(
       expected,
       MinimalCollection(elements: base).lazy.filter { _ in return true },
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % else:
     check${traversal}${kind}(
       expected,
       Minimal${traversal}${kind}(elements: base).lazy.filter { _ in return true },
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % end
   }
   do {
-    var resiliency = CollectionMisuseResiliencyChecks.all
-    resiliency.callNextOnExhaustedGenerator = false
     let predicate: Int -> Bool = { $0 % 3 == 0 || $0 % 5 == 0 }
 
     let base = randArray(500)
@@ -133,23 +112,17 @@ CollectionTests.test("LazyFilterCollection instances (${traversal}${kind})") {
 % if kind == 'Sequence':
     checkSequence(
       expected,
-      MinimalSequence(elements: base).lazy.filter(predicate),
-      resiliencyChecks: resiliency
-    )
+      MinimalSequence(elements: base).lazy.filter(predicate))
 % elif traversal == '' and kind == 'Collection':
     checkForwardCollection(
       expected,
       MinimalCollection(elements: base).lazy.filter(predicate),
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % else:
     check${traversal}${kind}(
       expected,
       Minimal${traversal}${kind}(elements: base).lazy.filter(predicate),
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % end
   }
 }

validation-test/stdlib/Collection/LazyMapCollection.swift.gyb

@@ -60,58 +60,38 @@ CollectionTests.add${traversal}${kind}Tests(
 % for (traversal, kind) in variations:
 CollectionTests.test("LazyMapCollection instances (${traversal}${kind})") {
   do {
-    // MinimalIterator will error if next() is called after exhaustion
-    var resiliency = CollectionMisuseResiliencyChecks.all
-    resiliency.callNextOnExhaustedGenerator = false 
-
     let expected = ["convent", "conform", "constrict", "condone"]
     let base = ["vent", "form", "strict", "done"]
 % if kind == 'Sequence':
     checkSequence(
       expected,
-      MinimalSequence(elements: base).lazy.map { "con" + $0 },
-      resiliencyChecks: resiliency
-    )
+      MinimalSequence(elements: base).lazy.map { "con" + $0 })
 % elif traversal == '' and kind == 'Collection':
     checkForwardCollection(expected,
       MinimalCollection(elements: base).lazy.map { "con" + $0 },
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % else:
     check${traversal}${kind}(expected,
       Minimal${traversal}${kind}(elements: base).lazy.map { "con" + $0 },
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % end
   }
   do {
-    // MinimalIterator will error if next() is called after exhaustion
-    var resiliency = CollectionMisuseResiliencyChecks.all
-    resiliency.callNextOnExhaustedGenerator = false 
-
     let expected = [1, 4, 9, 16, 25, 36, 49, 64]
     let base = [1, 2, 3, 4, 5, 6, 7, 8]
 % if kind == 'Sequence':
     checkSequence(
       expected,
-      MinimalSequence(elements: base).lazy.map { $0 * $0 },
-      resiliencyChecks: resiliency
-    )
+      MinimalSequence(elements: base).lazy.map { $0 * $0 })
 % elif traversal == '' and kind == 'Collection':
     checkForwardCollection(expected,
       MinimalCollection(elements: base).lazy.map { $0 * $0 },
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % else:
     check${traversal}${kind}(
       expected,
       Minimal${traversal}${kind}(elements: base).lazy.map { $0 * $0 },
-      resiliencyChecks: resiliency,
-      sameValue: { $0 == $1 }
-    )
+      sameValue: { $0 == $1 })
 % end
   }
 }