[stdlib] Apply tail style "where" clause to stdlib/public/core

Author: rintaro

stdlib/public/core/ArrayBufferProtocol.swift

@@ -71,11 +71,11 @@ public protocol _ArrayBufferProtocol
   ///
   /// - Precondition: This buffer is backed by a uniquely-referenced
   /// `_ContiguousArrayBuffer`.
-  mutating func replace<C : Collection where C.Iterator.Element == Element>(
+  mutating func replace<C>(
     subRange: Range<Int>,
     with newCount: Int,
     elementsOf newValues: C
-  )
+  ) where C : Collection, C.Iterator.Element == Element
 
   /// Returns a `_SliceBuffer` containing the elements in `bounds`.
   subscript(bounds: Range<Int>) -> _SliceBuffer<Element> { get }
@@ -131,13 +131,11 @@ extension _ArrayBufferProtocol where Index == Int {
     return firstElementAddress
   }
 
-  public mutating func replace<
-    C : Collection where C.Iterator.Element == Element
-  >(
+  public mutating func replace<C>(
     subRange: Range<Int>,
     with newCount: Int,
     elementsOf newValues: C
-  ) {
+  ) where C : Collection, C.Iterator.Element == Element {
     _sanityCheck(startIndex == 0, "_SliceBuffer should override this function.")
     let oldCount = self.count
     let eraseCount = subRange.count

stdlib/public/core/ArrayType.swift

@@ -45,9 +45,8 @@ protocol _ArrayProtocol
   mutating func reserveCapacity(_ minimumCapacity: Int)
 
   /// Operator form of `append(contentsOf:)`.
-  func += <
-    S : Sequence where S.Iterator.Element == Iterator.Element
-  >(lhs: inout Self, rhs: S)
+  func += <S : Sequence>(lhs: inout Self, rhs: S)
+    where S.Iterator.Element == Iterator.Element
 
   /// Insert `newElement` at index `i`.
   ///

stdlib/public/core/Arrays.swift.gyb

@@ -1024,9 +1024,9 @@ extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
   ///     // Prints "["Gold", "Cerise", "Magenta", "Vermillion"]"
   ///
   /// - Parameter s: The sequence of elements to turn into an array.
-  public init<
-    S : Sequence where S.Iterator.Element == Element
-  >(_ s: S) {
+  public init<S : Sequence>(_ s: S)
+    where S.Iterator.Element == Element {
+
     self = ${Self}(_Buffer(s._copyToNativeArrayBuffer(),
       shiftedToStartIndex: 0))
   }
@@ -1275,11 +1275,8 @@ extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
   /// - Parameter newElements: The elements to append to the array.
   ///
   /// - Complexity: O(*n*), where *n* is the length of the resulting array.
-  public mutating func append<
-    S : Sequence
-    where
-    S.Iterator.Element == Element
-  >(contentsOf newElements: S) {
+  public mutating func append<S : Sequence>(contentsOf newElements: S)
+    where S.Iterator.Element == Element {
     let oldCount = self.count
     let capacity = self.capacity
     let newCount = oldCount + newElements.underestimatedCount
@@ -1309,11 +1306,9 @@ extension ${Self} : RangeReplaceableCollection, _ArrayProtocol {
   /// - Parameter newElements: The elements to append to the array.
   ///
   /// - Complexity: O(*n*), where *n* is the length of the resulting array.
-  public mutating func append<
-    C : Collection
-    where
-    C.Iterator.Element == Element
-  >(contentsOf newElements: C) {
+  public mutating func append<C : Collection>(contentsOf newElements: C)
+    where C.Iterator.Element == Element {
+
     let newElementsCount = numericCast(newElements.count) as Int
 
     let oldCount = self.count
@@ -1624,14 +1619,17 @@ internal struct _InitializeMemoryFromCollection<
 
 // FIXME(ABI): add argument labels.
 @inline(never)
-internal func _arrayOutOfPlaceReplace<
-  B : _ArrayBufferProtocol, C : Collection
-  where
+internal func _arrayOutOfPlaceReplace<B, C>(
+  _ source: inout B,
+  _ bounds: Range<Int>,
+  _ newValues: C,
+  _ insertCount: Int
+) where
+  B : _ArrayBufferProtocol,
+  C : Collection,
   C.Iterator.Element == B.Element,
-  B.Index == Int
->(
-  _ source: inout B, _ bounds: Range<Int>, _ newValues: C, _ insertCount: Int
-) {
+  B.Index == Int {
+
   let growth = insertCount - bounds.count
   let newCount = source.count + growth
   var newBuffer = _forceCreateUniqueMutableBuffer(
@@ -1694,11 +1692,10 @@ extension ${Self} {
   ///   array with an empty collection; otherwise, O(*n*), where *n* is the
   ///   length of the array.
   @_semantics("array.mutate_unknown")
-  public mutating func replaceSubrange<
-    C: Collection where C.Iterator.Element == _Buffer.Element
-  >(
-    _ subrange: Range<Int>, with newElements: C
-  ) {
+  public mutating func replaceSubrange<C>(
+    _ subrange: Range<Int>,
+    with newElements: C
+  ) where C : Collection, C.Iterator.Element == _Buffer.Element {
     _precondition(subrange.lowerBound >= self._buffer.startIndex,
       "${Self} replace: subrange start is negative")
 
@@ -1839,17 +1836,18 @@ internal protocol _PointerFunction {
 /// As an optimization, may move elements out of source rather than
 /// copying when it isUniquelyReferenced.
 @inline(never)
-internal func _arrayOutOfPlaceUpdate<
-  _Buffer : _ArrayBufferProtocol, Initializer : _PointerFunction
-  where Initializer.Element == _Buffer.Element,
-  _Buffer.Index == Int
->(
+internal func _arrayOutOfPlaceUpdate<_Buffer, Initializer>(
   _ source: inout _Buffer,
   _ dest: inout _ContiguousArrayBuffer<_Buffer.Element>,
   _ headCount: Int, // Count of initial source elements to copy/move
   _ newCount: Int,  // Number of new elements to insert
   _ initializeNewElements: Initializer
-) {
+) where
+  _Buffer : _ArrayBufferProtocol,
+  Initializer : _PointerFunction,
+  Initializer.Element == _Buffer.Element,
+  _Buffer.Index == Int {
+
   _sanityCheck(headCount >= 0)
   _sanityCheck(newCount >= 0)
 
@@ -1931,11 +1929,12 @@ internal struct _IgnorePointer<T> : _PointerFunction {
 
 @_versioned
 @inline(never)
-internal func _outlinedMakeUniqueBuffer<
-  _Buffer : _ArrayBufferProtocol where _Buffer.Index == Int
->(
+internal func _outlinedMakeUniqueBuffer<_Buffer>(
   _ buffer: inout _Buffer, bufferCount: Int
-) {
+) where
+  _Buffer : _ArrayBufferProtocol,
+  _Buffer.Index == Int {
+
   if _fastPath(
       buffer.requestUniqueMutableBackingBuffer(minimumCapacity: bufferCount) != nil) {
     return
@@ -1946,11 +1945,12 @@ internal func _outlinedMakeUniqueBuffer<
   _arrayOutOfPlaceUpdate(&buffer, &newBuffer, bufferCount, 0, _IgnorePointer())
 }
 
-internal func _arrayReserve<
-  _Buffer : _ArrayBufferProtocol where _Buffer.Index == Int
->(
+internal func _arrayReserve<_Buffer>(
   _ buffer: inout _Buffer, _ minimumCapacity: Int
-) {
+) where
+  _Buffer : _ArrayBufferProtocol,
+  _Buffer.Index == Int {
+
   let count = buffer.count
   let requiredCapacity = max(count, minimumCapacity)
 
@@ -1967,29 +1967,28 @@ internal func _arrayReserve<
 }
 
 public // SPI(Foundation)
-func _extractOrCopyToNativeArrayBuffer<
-  Buffer : _ArrayBufferProtocol
+func _extractOrCopyToNativeArrayBuffer<Buffer>(
+  _ source: Buffer
+) -> _ContiguousArrayBuffer<Buffer.Iterator.Element>
   where
-  Buffer.Iterator.Element == Buffer.Element
->(_ source: Buffer)
-  -> _ContiguousArrayBuffer<Buffer.Iterator.Element>
-{
+  Buffer : _ArrayBufferProtocol,
+  Buffer.Iterator.Element == Buffer.Element {
+
   if let n = source.requestNativeBuffer() {
     return n
   }
   return _copyCollectionToNativeArrayBuffer(source)
 }
 
 /// Append items from `newItems` to `buffer`.
-internal func _arrayAppendSequence<
+internal func _arrayAppendSequence<Buffer, S>(
+  _ buffer: inout Buffer, _ newItems: S
+) where
   Buffer : _ArrayBufferProtocol,
-  S : Sequence
-  where
+  S : Sequence,
   S.Iterator.Element == Buffer.Element,
-  Buffer.Index == Int
->(
-  _ buffer: inout Buffer, _ newItems: S
-) {
+  Buffer.Index == Int {
+
   var stream = newItems.makeIterator()
   var nextItem = stream.next()
 
@@ -2161,18 +2160,16 @@ extension ${Self} {
   }
 
   @available(*, unavailable, renamed: "replaceSubrange")
-  public mutating func replaceRange<
-    C : Collection where C.Iterator.Element == _Buffer.Element
-  >(_ subRange: Range<Int>, with newElements: C) {
+  public mutating func replaceRange<C>(
+    _ subRange: Range<Int>,
+    with newElements: C
+  ) where C : Collection, C.Iterator.Element == _Buffer.Element {
     Builtin.unreachable()
   }
 
   @available(*, unavailable, renamed: "append(contentsOf:)")
-  public mutating func appendContentsOf<
-    S : Sequence
-    where
-    S.Iterator.Element == Element
-  >(_ newElements: S) {
+  public mutating func appendContentsOf<S : Sequence>(_ newElements: S)
+    where S.Iterator.Element == Element {
     Builtin.unreachable()
   }
 }

stdlib/public/core/ClosedRange.swift

@@ -13,24 +13,26 @@
 // FIXME: swift-3-indexing-model: Generalize all tests to check both
 // [Closed]Range and [Closed]CountableRange.
 
-// WORKAROUND rdar://25214598 - should be Bound : Strideable
-internal enum _ClosedRangeIndexRepresentation<
-  Bound : Comparable where Bound : _Strideable, Bound.Stride : Integer
-> {
+internal enum _ClosedRangeIndexRepresentation<Bound>
+  where
+  // WORKAROUND rdar://25214598 - should be Bound : Strideable
+  Bound : protocol<_Strideable, Comparable>,
+  Bound.Stride : Integer {
   case pastEnd
   case inRange(Bound)
 }
 
 // FIXME(ABI)(compiler limitation): should be a nested type in
 // `ClosedRange`.
 /// A position in a `CountableClosedRange` instance.
-public struct ClosedRangeIndex<
+public struct ClosedRangeIndex<Bound> : Comparable
+  where
   // WORKAROUND rdar://25214598 - should be Bound : Strideable
-  Bound : Comparable where Bound : _Strideable, Bound.Stride : Integer
   // swift-3-indexing-model: should conform to _Strideable, otherwise
   // CountableClosedRange is not interchangeable with CountableRange in all
   // contexts.
-> : Comparable {
+  Bound : protocol<_Strideable, Comparable>,
+  Bound.Stride : Integer {
   /// Creates the "past the end" position.
   internal init() { _value = .pastEnd }
 
@@ -101,11 +103,11 @@ public func < <B>(lhs: ClosedRangeIndex<B>, rhs: ClosedRangeIndex<B>) -> Bool {
 
 // WORKAROUND: needed because of rdar://25584401
 /// An iterator over the elements of a `CountableClosedRange` instance.
-public struct ClosedRangeIterator<
-  Bound : protocol<_Strideable, Comparable>
+public struct ClosedRangeIterator<Bound> : IteratorProtocol, Sequence
   where
-  Bound.Stride : SignedInteger
-> : IteratorProtocol, Sequence {
+  // WORKAROUND rdar://25214598 - should be just Bound : Strideable
+  Bound : protocol<_Strideable, Comparable>,
+  Bound.Stride : SignedInteger {
 
   internal init(_range r: CountableClosedRange<Bound>) {
     _nextResult = r.lowerBound
@@ -175,12 +177,11 @@ public struct ClosedRangeIterator<
 /// `stride(from:through:by:)` function.
 ///
 /// - SeeAlso: `CountableRange`, `ClosedRange`, `Range`
-public struct CountableClosedRange<
-  // WORKAROUND rdar://25214598 - should be just Bound : Strideable
-  Bound : protocol<_Strideable, Comparable>
+public struct CountableClosedRange<Bound> : RandomAccessCollection
   where
-  Bound.Stride : SignedInteger
-> : RandomAccessCollection {
+  // WORKAROUND rdar://25214598 - should be just Bound : Strideable
+  Bound : protocol<_Strideable, Comparable>,
+  Bound.Stride : SignedInteger {
 
   /// The range's lower bound.
   public let lowerBound: Bound
@@ -387,14 +388,13 @@ public func ... <Bound : Comparable> (minimum: Bound, maximum: Bound)
 ///   - minimum: The lower bound for the range.
 ///   - maximum: The upper bound for the range.
 @_transparent
-public func ... <
-  // WORKAROUND rdar://25214598 - should be just Bound : Strideable
-  Bound : protocol<_Strideable, Comparable>
-  where
-  Bound.Stride : SignedInteger
-> (
+public func ... <Bound> (
   minimum: Bound, maximum: Bound
-) -> CountableClosedRange<Bound> {
+) -> CountableClosedRange<Bound>
+  where
+  // WORKAROUND rdar://25214598 - should be just Bound : Strideable
+  Bound : protocol<_Strideable, Comparable>,
+  Bound.Stride : SignedInteger {
   // FIXME: swift-3-indexing-model: tests for traps.
   _precondition(
     minimum <= maximum, "Can't form Range with upperBound < lowerBound")

stdlib/public/core/CompilerProtocols.swift

@@ -195,9 +195,8 @@ public protocol RawRepresentable {
 /// - Parameters:
 ///   - lhs: A raw-representable instance.
 ///   - rhs: A second raw-representable instance.
-public func == <
-  T : RawRepresentable where T.RawValue : Equatable
->(lhs: T, rhs: T) -> Bool {
+public func == <T : RawRepresentable>(lhs: T, rhs: T) -> Bool
+  where T.RawValue : Equatable {
   return lhs.rawValue == rhs.rawValue
 }
 
@@ -206,9 +205,8 @@ public func == <
 /// - Parameters:
 ///   - lhs: A raw-representable instance.
 ///   - rhs: A second raw-representable instance.
-public func != <
-  T : RawRepresentable where T.RawValue : Equatable
->(lhs: T, rhs: T) -> Bool {
+public func != <T : RawRepresentable>(lhs: T, rhs: T) -> Bool
+  where T.RawValue : Equatable {
   return lhs.rawValue != rhs.rawValue
 }
 
@@ -219,9 +217,8 @@ public func != <
 /// - Parameters:
 ///   - lhs: A raw-representable instance.
 ///   - rhs: A second raw-representable instance.
-public func != <
-  T : Equatable where T : RawRepresentable, T.RawValue : Equatable
->(lhs: T, rhs: T) -> Bool {
+public func != <T : Equatable>(lhs: T, rhs: T) -> Bool
+  where T : RawRepresentable, T.RawValue : Equatable {
   return lhs.rawValue != rhs.rawValue
 }
 

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -495,9 +495,10 @@ public struct _ContiguousArrayBuffer<Element> : _ArrayBufferProtocol {
 }
 
 /// Append the elements of `rhs` to `lhs`.
-public func += <
-  Element, C : Collection where C.Iterator.Element == Element
-> (lhs: inout _ContiguousArrayBuffer<Element>, rhs: C) {
+public func += <Element, C : Collection>(
+  lhs: inout _ContiguousArrayBuffer<Element>, rhs: C
+) where C.Iterator.Element == Element {
+
   let oldCount = lhs.count
   let newCount = oldCount + numericCast(rhs.count)