[test] Update prototypes to use conditional conformance (#14274)

Author: natecook1000

test/Prototypes/Algorithms.swift.gyb renamed to test/Prototypes/Algorithms.swift

@@ -9,25 +9,12 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-// RUN: %empty-directory(%t)
-// RUN: %gyb -DWORD_BITS=%target-ptrsize %s -o %t/out.swift
-// RUN: %line-directive %t/out.swift -- %target-build-swift -parse-stdlib %t/out.swift -o %t/a.out -Onone -swift-version 4
-// RUN: %line-directive %t/out.swift -- %target-run %t/a.out
-
+// RUN: %target-run-stdlib-swift
 // REQUIRES: executable_test
 
 import Swift
 import StdlibUnittest
 
-%{
-
-from gyb_stdlib_support import (
-    TRAVERSALS,
-    collectionForTraversal,
-)
-
-}%
-
 //===--- Rotate -----------------------------------------------------------===//
 //===----------------------------------------------------------------------===//
 
@@ -286,86 +273,61 @@ extension MutableCollection where Self: RandomAccessCollection {
 // Q: Add a ConcatenatedSequence for consistency? Would be nice to be able to
 // call `let seqAB = concatenate(seqA, seqB)`.
 
-/// Represents a position in either the first or second collection of a
-/// `ConcatenatedCollection`.
-internal enum _ConcatenatedCollectionIndexRepresentation<
-  I1 : Comparable, I2 : Comparable
-> {
-  case first(I1)
-  case second(I2)
-}
+/// A concatenation of two collections with the same element type.
+public struct Concatenation<C1 : Collection, C2: Collection>: Collection
+  where C1.Element == C2.Element
+{
+  let _base1: C1
+  let _base2: C2
 
-/// A position in a `ConcatenatedCollection` collection.
-public struct ConcatenatedCollectionIndex<
-  C1 : Collection, C2 : Collection
-> : Comparable {
-  /// Creates a new index into the first underlying collection.
-  internal init(first i: C1.Index) {
-    _position = .first(i)
-  }
-
-  /// Creates a new index into the second underlying collection.
-  internal init(second i: C2.Index) {
-    _position = .second(i)
-  }
-
-  internal let _position:
-    _ConcatenatedCollectionIndexRepresentation<C1.Index, C2.Index>
-
-  public static func < (
-    lhs: ConcatenatedCollectionIndex, rhs: ConcatenatedCollectionIndex
-  ) -> Bool {
-    switch (lhs._position, rhs._position) {
-    case (.first, .second):
-      return true
-    case (.second, .first):
-      return false
-    case let (.first(l), .first(r)):
-      return l < r
-    case let (.second(l), .second(r)):
-      return l < r
-    }
+  init(_base1: C1, base2: C2) {
+    self._base1 = _base1
+    self._base2 = base2
   }
 
-  public static func == (
-    lhs: ConcatenatedCollectionIndex, rhs: ConcatenatedCollectionIndex
-  ) -> Bool {
-    switch (lhs._position, rhs._position) {
-    case let (.first(l), .first(r)):
-      return l == r
-    case let (.second(l), .second(r)):
-      return l == r
-    default:
-      return false
+  /// A position in a `Concatenation`.
+  public struct Index : Comparable {
+    internal enum _Representation : Equatable {
+      case first(C1.Index)
+      case second(C2.Index)
     }
-  }
-}
 
-% for Traversal in TRAVERSALS:
-%   Collection = collectionForTraversal(Traversal)
-%   Self = "Concatenated" + Collection
+    /// Creates a new index into the first underlying collection.
+    internal init(first i: C1.Index) {
+      _position = .first(i)
+    }
 
-/// A concatenation of two collections with the same element type.
-public struct ${Self}<C1 : ${Collection}, C2: ${Collection}>: ${Collection}
-  where C1.Element == C2.Element {
+    /// Creates a new index into the second underlying collection.
+    internal init(second i: C2.Index) {
+      _position = .second(i)
+    }
 
-  init(_base1: C1, base2: C2) {
-    self._base1 = _base1
-    self._base2 = base2
+    internal let _position: _Representation
+
+    public static func < (lhs: Index, rhs: Index) -> Bool {
+      switch (lhs._position, rhs._position) {
+      case (.first, .second):
+        return true
+      case (.second, .first):
+        return false
+      case let (.first(l), .first(r)):
+        return l < r
+      case let (.second(l), .second(r)):
+        return l < r
+      }
+    }
   }
 
-  public typealias Index = ConcatenatedCollectionIndex<C1, C2>
-
   public var startIndex: Index {
     // If `_base1` is empty, then `_base2.startIndex` is either a valid position
     // of an element or equal to `_base2.endIndex`.
     return _base1.isEmpty
-      ? ConcatenatedCollectionIndex(second: _base2.startIndex)
-      : ConcatenatedCollectionIndex(first: _base1.startIndex)
+      ? Index(second: _base2.startIndex)
+      : Index(first: _base1.startIndex)
   }
 
   public var endIndex: Index {
-    return ConcatenatedCollectionIndex(second: _base2.endIndex)
+    return Index(second: _base2.endIndex)
   }
 
   public subscript(i: Index) -> C1.Element {
@@ -383,29 +345,33 @@ public struct ${Self}<C1 : ${Collection}, C2: ${Collection}>: ${Collection}
       _sanityCheck(i != _base1.endIndex)
       let next = _base1.index(after: i)
       return next == _base1.endIndex
-        ? ConcatenatedCollectionIndex(second: _base2.startIndex)
-        : ConcatenatedCollectionIndex(first: next)
+        ? Index(second: _base2.startIndex)
+        : Index(first: next)
     case let .second(i):
-      return ConcatenatedCollectionIndex(second: _base2.index(after: i))
+      return Index(second: _base2.index(after: i))
     }
   }
+}
 
-%   if Traversal in ['Bidirectional', 'RandomAccess']:
+extension Concatenation : BidirectionalCollection
+  where C1: BidirectionalCollection, C2: BidirectionalCollection
+{
   public func index(before i: Index) -> Index {
     assert(i != startIndex, "Can't advance before startIndex")
     switch i._position {
     case let .first(i):
-      return ConcatenatedCollectionIndex(first: _base1.index(before: i))
+      return Index(first: _base1.index(before: i))
     case let .second(i):
       return i == _base2.startIndex
-        ? ConcatenatedCollectionIndex(
-            first: _base1.index(before: _base1.endIndex))
-        : ConcatenatedCollectionIndex(second: _base2.index(before: i))
+        ? Index(first: _base1.index(before: _base1.endIndex))
+        : Index(second: _base2.index(before: i))
     }
   }
-%   end
+}
 
-%   if Traversal is 'RandomAccess':
+extension Concatenation : RandomAccessCollection
+  where C1: RandomAccessCollection, C2: RandomAccessCollection
+{
   public func index(_ i: Index, offsetBy n: Int) -> Index {
     if n == 0 { return i }
     return n > 0 ? _offsetForward(i, by: n) : _offsetBackward(i, by: -n)
@@ -418,15 +384,13 @@ public struct ${Self}<C1 : ${Collection}, C2: ${Collection}>: ${Collection}
     case let .first(i):
       let d: Int = _base1.distance(from: i, to: _base1.endIndex)
       if n < d {
-        return ConcatenatedCollectionIndex(
-          first: _base1.index(i, offsetBy: numericCast(n)))
+        return Index(first: _base1.index(i, offsetBy: numericCast(n)))
       } else {
-        return ConcatenatedCollectionIndex(
+        return Index(
           second: _base2.index(_base2.startIndex, offsetBy: numericCast(n - d)))
       }
     case let .second(i):
-      return ConcatenatedCollectionIndex(
-        second: _base2.index(i, offsetBy: numericCast(n)))
+      return Index(second: _base2.index(i, offsetBy: numericCast(n)))
     }
   }
 
@@ -435,112 +399,100 @@ public struct ${Self}<C1 : ${Collection}, C2: ${Collection}>: ${Collection}
   ) -> Index {
     switch i._position {
     case let .first(i):
-      return ConcatenatedCollectionIndex(
-        first: _base1.index(i, offsetBy: -numericCast(n)))
+      return Index(first: _base1.index(i, offsetBy: -numericCast(n)))
     case let .second(i):
       let d: Int = _base2.distance(from: _base2.startIndex, to: i)
       if n <= d {
-        return ConcatenatedCollectionIndex(
-          second: _base2.index(i, offsetBy: -numericCast(n)))
+        return Index(second: _base2.index(i, offsetBy: -numericCast(n)))
       } else {
-        return ConcatenatedCollectionIndex(
+        return Index(
           first: _base1.index(_base1.endIndex, offsetBy: -numericCast(n - d)))
       }
     }
   }
-%   end
-
-  let _base1: C1
-  let _base2: C2
 }
 
 /// Returns a new collection that presents a view onto the elements of the
 /// first collection and then the elements of the second collection.
-func concatenate<
-  C1 : ${Collection}, C2 : ${Collection}
->(_ first: C1, _ second: C2) -> ${Self}<C1, C2>
-where C1.Element == C2.Element {
-  return ${Self}(_base1: first, base2: second)
+func concatenate<C1 : Collection, C2 : Collection>(
+  _ first: C1,
+  _ second: C2)
+  -> Concatenation<C1, C2> where C1.Element == C2.Element
+{
+  return Concatenation(_base1: first, base2: second)
 }
 
-% end
-
 //===--- RotatedCollection ------------------------------------------------===//
 //===----------------------------------------------------------------------===//
 
-/// A position in a rotated collection.
-public struct RotatedCollectionIndex<Base : Collection> : Comparable {
-  internal let _index:
-    ConcatenatedCollectionIndex<Base.SubSequence, Base.SubSequence>
+/// A rotated view onto a collection.
+public struct RotatedCollection<Base : Collection> : Collection {
+  let _base: Base
+  let _indices: Concatenation<Base.Indices, Base.Indices>
 
-  public static func < (
-    lhs: RotatedCollectionIndex, rhs: RotatedCollectionIndex
-  ) -> Bool {
-    return lhs._index < rhs._index
-  }
-
-  public static func == (
-    lhs: RotatedCollectionIndex, rhs: RotatedCollectionIndex
-  ) -> Bool {
-    return lhs._index == rhs._index
+  init(_base: Base, shiftingToStart i: Base.Index) {
+    self._base = _base
+    self._indices = concatenate(_base.indices[i...], _base.indices[..<i])
   }
-}
 
-% for Traversal in TRAVERSALS:
-%   Collection = collectionForTraversal(Traversal)
-%   Self = "Rotated" + Collection
+  /// A position in a rotated collection.
+  public struct Index : Comparable {
+    internal let _index:
+      Concatenation<Base.Indices, Base.Indices>.Index
 
-/// A rotated view onto a `${Collection}`.
-public struct ${Self}<
-  Base : ${Collection}
-> : ${Collection} {
-  let _concatenation: Concatenated${Collection}<
-    Base.SubSequence, Base.SubSequence>
-
-  init(_base: Base, shiftingToStart i: Base.Index) {
-    _concatenation = concatenate(_base[i...], _base[..<i])
+    public static func < (lhs: Index, rhs: Index) -> Bool {
+      return lhs._index < rhs._index
+    }
   }
 
-  public typealias Index = RotatedCollectionIndex<Base>
-
   public var startIndex: Index {
-    return RotatedCollectionIndex(_index: _concatenation.startIndex)
+    return Index(_index: _indices.startIndex)
   }
 
   public var endIndex: Index {
-    return RotatedCollectionIndex(_index: _concatenation.endIndex)
+    return Index(_index: _indices.endIndex)
   }
 
   public subscript(i: Index) -> Base.SubSequence.Element {
-    return _concatenation[i._index]
+    return _base[_indices[i._index]]
   }
 
   public func index(after i: Index) -> Index {
-    return RotatedCollectionIndex(_index: _concatenation.index(after: i._index))
+    return Index(_index: _indices.index(after: i._index))
   }
 
-%   if Traversal in ['Bidirectional', 'RandomAccess']:
-  public func index(before i: Index) -> Index {
-    return RotatedCollectionIndex(
-      _index: _concatenation.index(before: i._index))
+  public func index(_ i: Index, offsetBy n: Int) -> Index {
+    return Index(_index: _indices.index(i._index, offsetBy: n))
   }
-%   end
 
-  public func index(_ i: Index, offsetBy n: Int) -> Index {
-    return RotatedCollectionIndex(
-      _index: _concatenation.index(i._index, offsetBy: n))
+  public func distance(from start: Index, to end: Index) -> Int {
+    return _indices.distance(from: start._index, to: end._index)
   }
 
   /// The shifted position of the base collection's `startIndex`.
   public var shiftedStartIndex: Index {
-    return RotatedCollectionIndex(
-      _index: ConcatenatedCollectionIndex(
-        second: _concatenation._base2.startIndex)
+    return Index(
+      _index: Concatenation<Base.Indices, Base.Indices>.Index(
+        second: _indices._base2.startIndex)
     )
   }
+
+  public func rotated(shiftingToStart i: Index) -> RotatedCollection<Base> {
+    return RotatedCollection(_base: _base, shiftingToStart: _indices[i._index])
+  }
 }
 
-extension ${Collection} {
+extension RotatedCollection : BidirectionalCollection
+  where Base : BidirectionalCollection {
+  public func index(before i: Index) -> Index {
+    return Index(_index: _indices.index(before: i._index))
+  }
+}
+
+extension RotatedCollection : RandomAccessCollection
+  where Base : RandomAccessCollection {}
+
+extension Collection {
   /// Returns a view of this collection with the elements reordered such the
   /// element at the given position ends up first.
   ///
@@ -556,13 +508,11 @@ extension ${Collection} {
   ///   result. `i` must be a valid index of the collection.
   /// - Returns: A rotated view on the elements of this collection, such that
   ///   the element at `i` is first.
-  func rotated(shiftingToStart i: Index) -> ${Self}<Self> {
-    return ${Self}(_base: self, shiftingToStart: i)
+  func rotated(shiftingToStart i: Index) -> RotatedCollection<Self> {
+    return RotatedCollection(_base: self, shiftingToStart: i)
   }
 }
 
-% end
-
 //===--- Stable Partition -------------------------------------------------===//
 //===----------------------------------------------------------------------===//