[Stdlib] Use SE-0142 to address ABI FIXMEs swiftlang#68, swiftlang#89, swiftlang#90, swiftlang#91.

Address ABI FIXME swiftlang#68 by using same-type constraints directly on an
associated type to describe the requirements on the Indices associated
type of the Collection protocol. ABI FIXMEs swiftlang#89, swiftlang#90, swiftlang#91 are all in
StdlibUnittest, and provoke warnings once swiftlang#68 is fixed, but it's nice
to clear them out.

Fixes SR-2121.

Author: DougGregor

Diff for: stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -370,10 +370,7 @@ public func expect${Mutable}CollectionType<X : ${Mutable}Collection>(
   X.SubSequence.Index == X.Index,
   // X.SubSequence.Indices == X.Indices, // FIXME(ABI)#3 (Recursive Protocol Constraints): can't have this constraint now.
   X.SubSequence.SubSequence == X.SubSequence,
-  X.Indices : Collection,
-  X.Indices.Iterator.Element == X.Index,
-  X.Indices.Index == X.Index,
-  X.Indices.SubSequence == X.Indices {}
+  X.Indices : Collection {}
 % end
 
 /// A slice is a `Collection` that when sliced returns an instance of
@@ -420,10 +417,7 @@ public func expectCollectionAssociatedTypes<X : Collection>(
   X.SubSequence.Index == X.Index,
   // X.SubSequence.Indices == X.Indices, // FIXME(ABI)#7 (Recursive Protocol Constraints): can't have this constraint now.
   X.SubSequence.SubSequence == X.SubSequence,
-  X.Indices : Collection,
-  X.Indices.Iterator.Element == X.Index,
-  X.Indices.Index == X.Index,
-  X.Indices.SubSequence == X.Indices {}
+  X.Indices : Collection {}
 
 /// Check that all associated types of a `BidirectionalCollection` are what we
 /// expect them to be.
@@ -443,10 +437,7 @@ public func expectBidirectionalCollectionAssociatedTypes<X : BidirectionalCollec
   X.SubSequence.Index == X.Index,
   // X.SubSequence.Indices == X.Indices, // FIXME(ABI)#9 (Recursive Protocol Constraints): can't have this constraint now.
   X.SubSequence.SubSequence == X.SubSequence,
-  X.Indices : BidirectionalCollection,
-  X.Indices.Iterator.Element == X.Index,
-  X.Indices.Index == X.Index,
-  X.Indices.SubSequence == X.Indices {}
+  X.Indices : BidirectionalCollection {}
 
 /// Check that all associated types of a `RandomAccessCollection` are what we
 /// expect them to be.
@@ -466,10 +457,7 @@ public func expectRandomAccessCollectionAssociatedTypes<X : RandomAccessCollecti
   X.SubSequence.Index == X.Index,
   // X.SubSequence.Indices == X.Indices, // FIXME(ABI)#11 (Recursive Protocol Constraints): can't have this constraint now.
   X.SubSequence.SubSequence == X.SubSequence,
-  X.Indices : RandomAccessCollection,
-  X.Indices.Iterator.Element == X.Index,
-  X.Indices.Index == X.Index,
-  X.Indices.SubSequence == X.Indices {}
+  X.Indices : RandomAccessCollection {}
 
 public struct AssertionResult : CustomStringConvertible {
   init(isPass: Bool) {
@@ -2000,10 +1988,7 @@ public func checkEquatable<Instances : Collection>(
   allowBrokenTransitivity: Bool = false,
   ${TRACE}
 ) where
-  Instances.Iterator.Element : Equatable,
-  // FIXME(ABI)#89 (Associated Types with where clauses): these constraints should be applied to
-  // associated types of Collection.
-  Instances.Indices.Iterator.Element == Instances.Index
+  Instances.Iterator.Element : Equatable
 {
   let indices = Array(instances.indices)
   _checkEquatableImpl(
@@ -2096,10 +2081,7 @@ public func checkHashable<Instances : Collection>(
   allowBrokenTransitivity: Bool = false,
   ${TRACE}
 ) where
-  Instances.Iterator.Element : Hashable,
-  // FIXME(ABI)#90 (Associated Types with where clauses): these constraints should be applied to
-  // associated types of Collection.
-  Instances.Indices.Iterator.Element == Instances.Index {
+  Instances.Iterator.Element : Hashable {
 
   checkEquatable(
     instances,
@@ -2191,10 +2173,7 @@ public func checkComparable<Instances : Collection>(
   oracle: (Instances.Index, Instances.Index) -> ExpectedComparisonResult,
   ${TRACE}
 ) where
-  Instances.Iterator.Element : Comparable,
-  // FIXME(ABI)#91 (Associated Types with where clauses): these constraints should be applied to
-  // associated types of Collection.
-  Instances.Indices.Iterator.Element == Instances.Index {
+  Instances.Iterator.Element : Comparable {
 
   // Also checks that equality is consistent with comparison and that
   // the oracle obeys the equality laws

Diff for: stdlib/public/core/Collection.swift

@@ -724,14 +724,13 @@ public protocol Collection : _Indexable, Sequence {
   /// A type that represents the indices that are valid for subscripting the
   /// collection, in ascending order.
   associatedtype Indices : _Indexable, Sequence = DefaultIndices<Self>
+    where Indices.Iterator.Element == Index,
+          Indices.Index == Index,
+          Indices.SubSequence == Indices
 
-  // FIXME(ABI)#68 (Associated Types with where clauses):
   // FIXME(ABI)#100 (Recursive Protocol Constraints):
   // associatedtype Indices : Collection
   //   where
-  //   Indices.Iterator.Element == Index,
-  //   Indices.Index == Index,
-  //   Indices.SubSequence == Indices
   //   = DefaultIndices<Self>
 
   /// The indices that are valid for subscripting the collection, in ascending

Diff for: stdlib/public/core/ExistentialCollection.swift.gyb

@@ -432,15 +432,9 @@ internal final class _${Kind}Box<S : ${Kind}> : _Any${Kind}Box<S.Iterator.Elemen
   S.SubSequence.SubSequence == S.SubSequence
 %   if Kind != 'Sequence':
   ,
-  S.SubSequence.Index == S.Index,
   S.SubSequence.Indices : ${Kind},
-  S.SubSequence.Indices.Iterator.Element == S.Index,
   S.SubSequence.Indices.Index == S.Index,
-  S.SubSequence.Indices.SubSequence == S.SubSequence.Indices,
-  S.Indices : ${Kind},
-  S.Indices.Iterator.Element == S.Index,
-  S.Indices.Index == S.Index,
-  S.Indices.SubSequence == S.Indices
+  S.Indices : ${Kind}
 %   end
 {
   internal typealias Element = S.Iterator.Element
@@ -1053,14 +1047,9 @@ public struct ${Self}<Element>
     C.SubSequence.Iterator.Element == Element,
     C.SubSequence.Index == C.Index,
     C.SubSequence.Indices : ${SubProtocol},
-    C.SubSequence.Indices.Iterator.Element == C.Index,
-    C.SubSequence.Indices.Index == C.Index,
-    C.SubSequence.Indices.SubSequence == C.SubSequence.Indices,
     C.SubSequence.SubSequence == C.SubSequence,
-    C.Indices : ${SubProtocol},
-    C.Indices.Iterator.Element == C.Index,
-    C.Indices.Index == C.Index,
-    C.Indices.SubSequence == C.Indices {
+    C.Indices : ${SubProtocol}
+     {
     // Traversal: ${Traversal}
     // SubTraversal: ${SubTraversal}
     self._box = _${SubProtocol}Box<C>(

Diff for: stdlib/public/core/Mirror.swift

@@ -220,16 +220,10 @@ public struct Mirror {
     // associated types of Collection.
     C.SubSequence : Collection,
     C.SubSequence.Iterator.Element == Child,
-    C.SubSequence.Index == C.Index,
     C.SubSequence.Indices : Collection,
-    C.SubSequence.Indices.Iterator.Element == C.Index,
     C.SubSequence.Indices.Index == C.Index,
-    C.SubSequence.Indices.SubSequence == C.SubSequence.Indices,
     C.SubSequence.SubSequence == C.SubSequence,
-    C.Indices : Collection,
-    C.Indices.Iterator.Element == C.Index,
-    C.Indices.Index == C.Index,
-    C.Indices.SubSequence == C.Indices {
+    C.Indices : Collection {
 
     self.subjectType = Subject.self
     self._makeSuperclassMirror = Mirror._superclassIterator(
@@ -281,10 +275,7 @@ public struct Mirror {
     // associated types of Collection.
     C.SubSequence : Collection,
     C.SubSequence.SubSequence == C.SubSequence,
-    C.Indices : Collection,
-    C.Indices.Iterator.Element == C.Index,
-    C.Indices.Index == C.Index,
-    C.Indices.SubSequence == C.Indices {
+    C.Indices : Collection {
 
     self.subjectType = Subject.self
     self._makeSuperclassMirror = Mirror._superclassIterator(

Diff for: validation-test/stdlib/CollectionType.swift.gyb

@@ -734,6 +734,19 @@ CollectionTypeTests.test("index(of:)/ContinueSearch") {
   }
 }
 
+//===----------------------------------------------------------------------===//
+// Collection indices types
+//===----------------------------------------------------------------------===//
+
+// SR-2121
+extension Collection {
+  func testIndicesElementType() {
+    for index in self.indices {
+      _ = self[index]
+    }
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Collection.split()
 //===----------------------------------------------------------------------===//