[stdlib] Stop precounting lazily filtered collections (swiftlang#8038)

This eliminates the counting step for a lazy filtered collection
when converting it into an array by treating the collection
as a sequence when copying elements. FlattenCollections already
have this behavior. (SR-4164)

Author: natecook1000

stdlib/public/core/Filter.swift.gyb

@@ -212,6 +212,22 @@ public struct ${Self}<
     return ${Slice}(base: self, bounds: bounds)
   }
 
+  // Any estimate of the number of elements that pass `_predicate` requires
+  // iterating the collection and evaluating each element, which can be costly,
+  // is unexpected, and usually doesn't pay for itself in saving time through
+  // preventing intermediate reallocations. (SR-4164)
+  public var underestimatedCount: Int { return 0 }
+
+  public func _copyToContiguousArray()
+    -> ContiguousArray<Base.Iterator.Element> {
+
+    // The default implementation of `_copyToContiguousArray` queries the
+    // `count` property, which evaluates `_predicate` for every element --
+    // see the note above `underestimatedCount`. Here we treat `self` as a
+    // sequence and only rely on underestimated count.
+    return _copySequenceToContiguousArray(self)
+  }
+
   // FIXME(ABI)#28 (Associated Types with where clauses): we actually want to add:
   //
   //   typealias SubSequence = ${Self}<Base.SubSequence>

test/stdlib/Filter.swift

@@ -54,4 +54,23 @@ FilterTests.test("filtering sequences") {
   expectEqualSequence([7, 14, 21, 28], f1)
 }
 
+FilterTests.test("single-count") {
+  // Check that we're only calling a lazy filter's predicate one time for
+  // each element in a sequence or collection.
+  var count = 0
+  let mod7AndCount: (Int) -> Bool = {
+    count += 1
+    return $0 % 7 == 0
+  }
+    
+  let f0 = (0..<30).makeIterator().lazy.filter(mod7AndCount)
+  let a0 = Array(f0)
+  expectEqual(30, count)
+
+  count = 0
+  let f1 = LazyFilterCollection(_base: 0..<30, mod7AndCount)
+  let a1 = Array(f1)
+  expectEqual(30, count)
+}
+
 runAllTests()