Changes for code review

Author: Russ Bishop

stdlib/private/StdlibCollectionUnittest/CheckSequenceType.swift

@@ -127,10 +127,8 @@ public struct FindTest {
   ) {
     self.expected = expected
     self.element = MinimalEquatableValue(element)
-    var elementIndex = 0
-    self.sequence = sequence.map {
-    	defer { elementIndex += 1 }
-    	return MinimalEquatableValue($0, identity: elementIndex) 
+    self.sequence = sequence.enumerate().map {
+      return MinimalEquatableValue($1, identity: $0) 
     }
     self.expectedLeftoverSequence = expectedLeftoverSequence.map(
       MinimalEquatableValue.init)
@@ -1775,6 +1773,30 @@ self.test("\(testNamePrefix).forEach/semantics") {
   }
 }
 
+//===----------------------------------------------------------------------===//
+// first()
+//===----------------------------------------------------------------------===//
+
+SequenceTypeTests.test("\(testNamePrefix).first/semantics") {
+  for test in findTests {
+    let s = MinimalSequence<MinimalEquatableValue>(elements: test.sequence)
+    let closureLifetimeTracker = LifetimeTracked(0)
+    let found = s.first {
+      _blackHole(closureLifetimeTracker)
+      return $0 == test.element
+    }
+    expectEqual(
+      test.expected == nil ? nil : test.element,
+      found,
+      stackTrace: SourceLocStack().with(test.loc))
+    if let found = found {
+      expectEqual(
+        test.expected, found.identity,
+        "find() should find only the first element matching its predicate")
+    }
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // _preprocessingPass()
 //===----------------------------------------------------------------------===//

stdlib/private/StdlibCollectionUnittest/LoggingWrappers.swift.gyb

@@ -81,6 +81,7 @@ public class SequenceLog {
   public static var map = TypeIndexed(0)
   public static var filter = TypeIndexed(0)
   public static var forEach = TypeIndexed(0)
+  public static var find = TypeIndexed(0)
   public static var dropFirst = TypeIndexed(0)
   public static var dropLast = TypeIndexed(0)
   public static var prefixMaxLength = TypeIndexed(0)
@@ -243,6 +244,13 @@ public struct ${Self}<
     Log.forEach[selfType] += 1
     try base.forEach(body)
   }
+  
+  public func find(
+    where predicate: @noescape (Base.Iterator.Element) throws -> Void
+  ) rethrows -> Base.Iterator.Element? {
+    Log.find[selfType] += 1
+    return base.find(where: predicate)
+  }
 
   public typealias SubSequence = Base.SubSequence
 

stdlib/public/core/Sequence.swift

@@ -567,13 +567,12 @@ public protocol Sequence {
   /// Returns the first element of the sequence that satisfies the given
   /// predicate or nil if no such element is found.
   ///
-  /// - Parameter predicate: A closure that takes an element of the
+  /// - Parameter where: A closure that takes an element of the
   ///   sequence as its argument and returns a Boolean value indicating
   ///   whether the element is a match.
   /// - Returns: The first match or `nil` if there was no match.
-  @warn_unused_result
   func first(
-    predicate: @noescape (Iterator.Element) throws -> Bool
+    where: @noescape (Iterator.Element) throws -> Bool
   ) rethrows -> Iterator.Element?
 
   @warn_unused_result
@@ -962,7 +961,6 @@ extension Sequence {
   ///
   /// - Parameter body: A closure that takes an element of the sequence as a
   ///   parameter.
-  @warn_unused_result
   public func forEach(
     _ body: @noescape (Iterator.Element) throws -> Void
   ) rethrows {
@@ -974,12 +972,12 @@ extension Sequence {
   /// Returns the first element of the sequence that satisfies the given
   /// predicate or nil if no such element is found.
   ///
-  /// - Parameter predicate: A closure that takes an element of the
+  /// - Parameter where: A closure that takes an element of the
   ///   sequence as its argument and returns a Boolean value indicating
   ///   whether the element is a match.
   /// - Returns: The first match or `nil` if there was no match.
   public func first(
-    predicate: @noescape (Iterator.Element) throws -> Bool
+    where predicate: @noescape (Iterator.Element) throws -> Bool
   ) rethrows -> Iterator.Element? {
     for element in self {
       if try predicate(element) {

validation-test/stdlib/SequenceType.swift.gyb

@@ -616,26 +616,6 @@ SequenceTypeTests.test("contains/Predicate") {
   }
 }
 
-//===----------------------------------------------------------------------===//
-// first()
-//===----------------------------------------------------------------------===//
-
-SequenceTypeTests.test("first/Predicate") {
-  for test in findTests {
-    let s = MinimalSequence<MinimalEquatableValue>(elements: test.sequence)
-    let found = s.first { $0 == test.element }
-    expectEqual(
-      test.expected == nil ? nil : test.element,
-      found,
-      stackTrace: SourceLocStack().with(test.loc))
-    if let found = found {
-      expectEqual(
-        test.expected, found.identity,
-        "find() should find only the first element matching its predicate")
-    }
-  }
-}
-
 //===----------------------------------------------------------------------===//
 // reduce()
 //===----------------------------------------------------------------------===//
@@ -964,6 +944,16 @@ SequenceTypeTests.test("forEach/dispatch") {
   expectCustomizable(tester, tester.log.forEach)
 }
 
+//===----------------------------------------------------------------------===//
+// first()
+//===----------------------------------------------------------------------===//
+
+SequenceTypeTests.test("first/dispatch") {
+  let tester = SequenceLog.dispatchTester([OpaqueValue(1)])
+  tester.first { return $0.value == 1 }
+  expectCustomizable(tester, tester.log.first)
+}
+
 //===----------------------------------------------------------------------===//
 // dropFirst()
 //===----------------------------------------------------------------------===//