Temporary removal of RangeSet/DiscontiguousSlice (swiftlang#35076)

Author: natecook1000

stdlib/public/core/CMakeLists.txt

@@ -209,14 +209,11 @@ set(SWIFTLIB_SOURCES
   Availability.swift
   CollectionDifference.swift
   CollectionOfOne.swift
-  DiscontiguousSlice.swift
   Diffing.swift
   FloatingPointRandom.swift
   Mirror.swift
   PlaygroundDisplay.swift
   CommandLine.swift
-  RangeSet.swift
-  RangeSetStorage.swift
   SliceBuffer.swift
   SIMDVector.swift
   UnfoldSequence.swift

stdlib/public/core/CollectionAlgorithms.swift

@@ -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, watchOS 9999, tvOS 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, watchOS 9999, tvOS 9999, *)
-  public func subranges(of element: Element) -> RangeSet<Index> {
-    subranges(where: { $0 == element })
-  }
-}
-
 //===----------------------------------------------------------------------===//
 // partition(by:)
 //===----------------------------------------------------------------------===//

stdlib/public/core/DiscontiguousSlice.swift

@@ -71,8 +71,6 @@
     "Sort.swift",
     "Range.swift",
     "ClosedRange.swift",
-    "RangeSet.swift",
-    "RangeSetStorage.swift",
     "CollectionOfOne.swift",
     "BridgingBuffer.swift",
     "Sequence.swift",
@@ -99,7 +97,6 @@
         "Filter.swift",
         "Reverse.swift",
         "Slice.swift",
-        "DiscontiguousSlice.swift",
         "DropWhile.swift",
         "PrefixWhile.swift",
         "LazyCollection.swift",

stdlib/public/core/GroupInfo.json

@@ -267,48 +267,6 @@ extension MutableCollection {
   }
 }
 
-//===----------------------------------------------------------------------===//
-// moveSubranges(_:to:)
-//===----------------------------------------------------------------------===//
-
-extension MutableCollection {
-  /// Moves the elements in the given subranges to just before the element at
-  /// the specified index.
-  ///
-  /// This example finds all the uppercase letters in the array and then
-  /// moves them to between `"i"` and `"j"`.
-  ///
-  ///     var letters = Array("ABCdeFGhijkLMNOp")
-  ///     let uppercaseRanges = letters.subranges(where: { $0.isUppercase })
-  ///     let rangeOfUppercase = letters.moveSubranges(uppercaseRanges, to: 10)
-  ///     // String(letters) == "dehiABCFGLMNOjkp"
-  ///     // rangeOfUppercase == 4..<13
-  ///
-  /// - Parameters:
-  ///   - subranges: The subranges of the elements to move.
-  ///   - insertionPoint: The index to use as the destination of the elements.
-  /// - Returns: The new bounds of the moved elements.
-  ///
-  /// - Complexity: O(*n* log *n*) where *n* is the length of the collection.
-  @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
-  @discardableResult
-  public mutating func moveSubranges(
-    _ subranges: RangeSet<Index>, to insertionPoint: Index
-  ) -> Range<Index> {
-    let lowerCount = distance(from: startIndex, to: insertionPoint)
-    let upperCount = distance(from: insertionPoint, to: endIndex)
-    let start = _indexedStablePartition(
-      count: lowerCount,
-      range: startIndex..<insertionPoint,
-      by: { subranges.contains($0) })
-    let end = _indexedStablePartition(
-      count: upperCount,
-      range: insertionPoint..<endIndex,
-      by: { !subranges.contains($0) })
-    return start..<end
-  }
-}
-
 //===----------------------------------------------------------------------===//
 // _rotate(in:shiftingToStart:)
 //===----------------------------------------------------------------------===//