[5.3] Revert RangeSet additions (#31827)

* Revert "test: move RangeSet test into validation-test"

This reverts commit e9aaef4.

* Revert "Add RangeSet and discontiguous collection operations (#28161)"

This reverts commit c6183ee.

Author: natecook1000

stdlib/private/StdlibCollectionUnittest/CMakeLists.txt

@@ -12,7 +12,6 @@ add_swift_target_library(swiftStdlibCollectionUnittest ${SWIFT_STDLIB_LIBRARY_BU
   CheckRangeReplaceableSliceType.swift
   CheckSequenceInstance.swift
   CheckSequenceType.swift
-  COWLoggingArray.swift
   LoggingWrappers.swift
   MinimalCollections.swift
   RangeSelection.swift

stdlib/private/StdlibCollectionUnittest/COWLoggingArray.swift

@@ -207,13 +207,10 @@ set(SWIFTLIB_SOURCES
   Availability.swift
   CollectionDifference.swift
   CollectionOfOne.swift
-  DiscontiguousSlice.swift
   Diffing.swift
   Mirror.swift
   PlaygroundDisplay.swift
   CommandLine.swift
-  RangeSet.swift
-  RangeSetStorage.swift
   SliceBuffer.swift
   SIMDVector.swift
   UnfoldSequence.swift

stdlib/public/core/CMakeLists.txt

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -209,70 +209,6 @@ extension BidirectionalCollection where Element: Equatable {
   }
 }
 
-//===----------------------------------------------------------------------===//
-// subranges(where:) / subranges(of:)
-//===----------------------------------------------------------------------===//
-
-extension Collection {
-  /// Returns the indices of all the elements that match the given predicate.
-  ///
-  /// For example, you can use this method to find all the places that a
-  /// vowel occurs in a string.
-  ///
-  ///     let str = "Fresh cheese in a breeze"
-  ///     let vowels: Set<Character> = ["a", "e", "i", "o", "u"]
-  ///     let allTheVowels = str.subranges(where: { vowels.contains($0) })
-  ///     // str[allTheVowels].count == 9
-  ///
-  /// - Parameter predicate: A closure that takes an element as its argument
-  ///   and returns a Boolean value that indicates whether the passed element
-  ///   represents a match.
-  /// - Returns: A set of the indices of the elements for which `predicate`
-  ///   returns `true`.
-  ///
-  /// - Complexity: O(*n*), where *n* is the length of the collection.
-  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
-  public func subranges(where predicate: (Element) throws -> Bool) rethrows
-    -> RangeSet<Index>
-  {
-    if isEmpty { return RangeSet() }
-
-    var result = RangeSet<Index>()
-    var i = startIndex
-    while i != endIndex {
-      let next = index(after: i)
-      if try predicate(self[i]) {
-        result._append(i..<next)
-      }
-      i = next
-    }
-
-    return result
-  }
-}
-
-extension Collection where Element: Equatable {
-  /// Returns the indices of all the elements that are equal to the given
-  /// element.
-  ///
-  /// For example, you can use this method to find all the places that a
-  /// particular letter occurs in a string.
-  ///
-  ///     let str = "Fresh cheese in a breeze"
-  ///     let allTheEs = str.subranges(of: "e")
-  ///     // str[allTheEs].count == 7
-  ///
-  /// - Parameter element: An element to look for in the collection.
-  /// - Returns: A set of the indices of the elements that are equal to
-  ///   `element`.
-  ///
-  /// - Complexity: O(*n*), where *n* is the length of the collection.
-  @available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *)
-  public func subranges(of element: Element) -> RangeSet<Index> {
-    subranges(where: { $0 == element })
-  }
-}
-
 //===----------------------------------------------------------------------===//
 // partition(by:)
 //===----------------------------------------------------------------------===//
@@ -433,81 +369,6 @@ extension MutableCollection where Self: BidirectionalCollection {
   }
 }
 
-//===----------------------------------------------------------------------===//
-// _indexedStablePartition / _partitioningIndex
-//===----------------------------------------------------------------------===//
-
-extension MutableCollection {
-  /// Moves all elements at the indices satisfying `belongsInSecondPartition`
-  /// into a suffix of the collection, preserving their relative order, and
-  /// returns the start of the resulting suffix.
-  ///
-  /// - Complexity: O(*n* log *n*) where *n* is the number of elements.
-  /// - Precondition:
-  ///   `n == distance(from: range.lowerBound, to: range.upperBound)`
-  internal mutating func _indexedStablePartition(
-    count n: Int,
-    range: Range<Index>,
-    by belongsInSecondPartition: (Index) throws-> Bool
-  ) rethrows -> Index {
-    if n == 0 { return range.lowerBound }
-    if n == 1 {
-      return try belongsInSecondPartition(range.lowerBound)
-        ? range.lowerBound
-        : range.upperBound
-    }
-    let h = n / 2, i = index(range.lowerBound, offsetBy: h)
-    let j = try _indexedStablePartition(
-      count: h,
-      range: range.lowerBound..<i,
-      by: belongsInSecondPartition)
-    let k = try _indexedStablePartition(
-      count: n - h,
-      range: i..<range.upperBound,
-      by: belongsInSecondPartition)
-    return _rotate(in: j..<k, shiftingToStart: i)
-  }
-}
-
-//===----------------------------------------------------------------------===//
-// _partitioningIndex(where:)
-//===----------------------------------------------------------------------===//
-
-extension Collection {
-  /// Returns the index of the first element in the collection that matches
-  /// the predicate.
-  ///
-  /// The collection must already be partitioned according to the predicate.
-  /// That is, there should be an index `i` where for every element in
-  /// `collection[..<i]` the predicate is `false`, and for every element
-  /// in `collection[i...]` the predicate is `true`.
-  ///
-  /// - Parameter predicate: A predicate that partitions the collection.
-  /// - Returns: The index of the first element in the collection for which
-  ///   `predicate` returns `true`.
-  ///
-  /// - Complexity: O(log *n*), where *n* is the length of this collection if
-  ///   the collection conforms to `RandomAccessCollection`, otherwise O(*n*).
-  internal func _partitioningIndex(
-    where predicate: (Element) throws -> Bool
-  ) rethrows -> Index {
-    var n = count
-    var l = startIndex
-    
-    while n > 0 {
-      let half = n / 2
-      let mid = index(l, offsetBy: half)
-      if try predicate(self[mid]) {
-        n = half
-      } else {
-        l = index(after: mid)
-        n -= half + 1
-      }
-    }
-    return l
-  }
-}
-
 //===----------------------------------------------------------------------===//
 // shuffled()/shuffle()
 //===----------------------------------------------------------------------===//