[stdlib] rename MutableSpan.extracting functions

Author: glessard

stdlib/public/core/Span/MutableSpan.swift

@@ -712,13 +712,31 @@ extension MutableSpan where Element: ~Copyable {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
+  mutating public func _mutatingExtracting(_ bounds: Range<Index>) -> Self {
+    _precondition(
+      UInt(bitPattern: bounds.lowerBound) <= UInt(bitPattern: _count) &&
+      UInt(bitPattern: bounds.upperBound) <= UInt(bitPattern: _count),
+      "Index range out of bounds"
+    )
+    return unsafe _mutatingExtracting(unchecked: bounds)
+  }
+
+  @available(*, deprecated, renamed: "_mutatingExtracting(_:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
   mutating public func extracting(_ bounds: Range<Index>) -> Self {
+    _mutatingExtracting(bounds)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(_ bounds: Range<Index>) -> Self {
     _precondition(
       UInt(bitPattern: bounds.lowerBound) <= UInt(bitPattern: _count) &&
       UInt(bitPattern: bounds.upperBound) <= UInt(bitPattern: _count),
       "Index range out of bounds"
     )
-    return unsafe extracting(unchecked: bounds)
+    return unsafe _consumingExtracting(unchecked: bounds)
   }
 
   /// Constructs a new span over the items within the supplied range of
@@ -739,13 +757,31 @@ extension MutableSpan where Element: ~Copyable {
   @unsafe
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(unchecked bounds: Range<Index>) -> Self {
+  mutating public func _mutatingExtracting(unchecked bounds: Range<Index>) -> Self {
     let delta = bounds.lowerBound &* MemoryLayout<Element>.stride
     let newStart = unsafe _pointer?.advanced(by: delta)
     let newSpan = unsafe Self(_unchecked: newStart, count: bounds.count)
     return unsafe _overrideLifetime(newSpan, mutating: &self)
   }
 
+  @unsafe
+  @available(*, deprecated, renamed: "_mutatingExtracting(unchecked:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
+  mutating public func extracting(unchecked bounds: Range<Index>) -> Self {
+    unsafe _mutatingExtracting(unchecked: bounds)
+  }
+
+  @unsafe
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(unchecked bounds: Range<Index>) -> Self {
+    let delta = bounds.lowerBound &* MemoryLayout<Element>.stride
+    let newStart = unsafe _pointer?.advanced(by: delta)
+    let newSpan = unsafe Self(_unchecked: newStart, count: bounds.count)
+    return unsafe _overrideLifetime(newSpan, copying: self)
+  }
+
   /// Constructs a new span over the items within the supplied range of
   /// positions within this span.
   ///
@@ -761,10 +797,27 @@ extension MutableSpan where Element: ~Copyable {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
+  mutating public func _mutatingExtracting(
+    _ bounds: some RangeExpression<Index>
+  ) -> Self {
+    _mutatingExtracting(bounds.relative(to: indices))
+  }
+
+  @available(*, deprecated, renamed: "_mutatingExtracting(_:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
   mutating public func extracting(
     _ bounds: some RangeExpression<Index>
   ) -> Self {
-    extracting(bounds.relative(to: indices))
+    _mutatingExtracting(bounds)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(
+    _ bounds: some RangeExpression<Index>
+  ) -> Self {
+    _consumingExtracting(bounds.relative(to: indices))
   }
 
   /// Constructs a new span over the items within the supplied range of
@@ -785,13 +838,35 @@ extension MutableSpan where Element: ~Copyable {
   @unsafe
   @_alwaysEmitIntoClient
   @lifetime(&self)
+  mutating public func _mutatingExtracting(
+    unchecked bounds: ClosedRange<Index>
+  ) -> Self {
+    let range = unsafe Range(
+      _uncheckedBounds: (bounds.lowerBound, bounds.upperBound + 1)
+    )
+    return unsafe _mutatingExtracting(unchecked: range)
+  }
+
+  @unsafe
+  @available(*, deprecated, renamed: "_mutatingExtracting(unchecked:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
   mutating public func extracting(
     unchecked bounds: ClosedRange<Index>
+  ) -> Self {
+    unsafe _mutatingExtracting(unchecked: bounds)
+  }
+
+  @unsafe
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(
+    unchecked bounds: ClosedRange<Index>
   ) -> Self {
     let range = unsafe Range(
-      _uncheckedBounds: (bounds.lowerBound, bounds.upperBound&+1)
+      _uncheckedBounds: (bounds.lowerBound, bounds.upperBound + 1)
     )
-    return unsafe extracting(unchecked: range)
+    return unsafe _consumingExtracting(unchecked: range)
   }
 
   /// Constructs a new span over all the items of this span.
@@ -805,10 +880,23 @@ extension MutableSpan where Element: ~Copyable {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(_: UnboundedRange) -> Self {
+  mutating public func _mutatingExtracting(_: UnboundedRange) -> Self {
     let newSpan = unsafe Self(_unchecked: _pointer, count: _count)
     return unsafe _overrideLifetime(newSpan, mutating: &self)
   }
+
+  @available(*, deprecated, renamed: "_mutatingExtracting(_:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
+  mutating public func extracting(_: UnboundedRange) -> Self {
+    _mutatingExtracting(...)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(_: UnboundedRange) -> Self {
+    self
+  }
 }
 
 // MARK: prefixes and suffixes
@@ -833,7 +921,7 @@ extension MutableSpan where Element: ~Copyable {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(first maxLength: Int) -> Self {
+  mutating public func _mutatingExtracting(first maxLength: Int) -> Self {
 #if compiler(>=5.3) && hasFeature(SendableCompletionHandlers)
     _precondition(maxLength >= 0, "Can't have a prefix of negative length")
     let newCount = min(maxLength, count)
@@ -844,6 +932,26 @@ extension MutableSpan where Element: ~Copyable {
 #endif
   }
 
+  @available(*, deprecated, renamed: "_mutatingExtracting(first:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
+  mutating public func extracting(first maxLength: Int) -> Self {
+    _mutatingExtracting(first: maxLength)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(first maxLength: Int) -> Self {
+#if compiler(>=5.3) && hasFeature(SendableCompletionHandlers)
+    _precondition(maxLength >= 0, "Can't have a prefix of negative length")
+    let newCount = min(maxLength, count)
+    let newSpan = unsafe Self(_unchecked: _pointer, count: newCount)
+    return unsafe _overrideLifetime(newSpan, copying: self)
+#else
+    fatalError("Unsupported compiler")
+#endif
+  }
+
   /// Returns a span over all but the given number of trailing elements.
   ///
   /// If the number of elements to drop exceeds the number of elements in
@@ -860,7 +968,7 @@ extension MutableSpan where Element: ~Copyable {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(droppingLast k: Int) -> Self {
+  mutating public func _mutatingExtracting(droppingLast k: Int) -> Self {
 #if compiler(>=5.3) && hasFeature(SendableCompletionHandlers)
     _precondition(k >= 0, "Can't drop a negative number of elements")
     let droppedCount = min(k, count)
@@ -872,6 +980,27 @@ extension MutableSpan where Element: ~Copyable {
 #endif
   }
 
+  @available(*, deprecated, renamed: "_mutatingExtracting(droppingLast:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
+  mutating public func extracting(droppingLast k: Int) -> Self {
+    _mutatingExtracting(droppingLast: k)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(droppingLast k: Int) -> Self {
+#if compiler(>=5.3) && hasFeature(SendableCompletionHandlers)
+    _precondition(k >= 0, "Can't drop a negative number of elements")
+    let droppedCount = min(k, count)
+    let newCount = count &- droppedCount
+    let newSpan = unsafe Self(_unchecked: _pointer, count: newCount)
+    return unsafe _overrideLifetime(newSpan, copying: self)
+#else
+    fatalError("Unsupported compiler")
+#endif
+  }
+
   /// Returns a span containing the final elements of the span,
   /// up to the given maximum length.
   ///
@@ -889,7 +1018,7 @@ extension MutableSpan where Element: ~Copyable {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(last maxLength: Int) -> Self {
+  mutating public func _mutatingExtracting(last maxLength: Int) -> Self {
 #if compiler(>=5.3) && hasFeature(SendableCompletionHandlers)
     _precondition(maxLength >= 0, "Can't have a suffix of negative length")
     let newCount = min(maxLength, count)
@@ -902,6 +1031,28 @@ extension MutableSpan where Element: ~Copyable {
 #endif
   }
 
+  @available(*, deprecated, renamed: "_mutatingExtracting(last:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
+  mutating public func extracting(last maxLength: Int) -> Self {
+    _mutatingExtracting(last: maxLength)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(last maxLength: Int) -> Self {
+#if compiler(>=5.3) && hasFeature(SendableCompletionHandlers)
+    _precondition(maxLength >= 0, "Can't have a suffix of negative length")
+    let newCount = min(maxLength, count)
+    let offset = (count &- newCount) * MemoryLayout<Element>.stride
+    let newStart = unsafe _pointer?.advanced(by: offset)
+    let newSpan = unsafe Self(_unchecked: newStart, count: newCount)
+    return unsafe _overrideLifetime(newSpan, copying: self)
+#else
+    fatalError("Unsupported compiler")
+#endif
+  }
+
   /// Returns a span over all but the given number of initial elements.
   ///
   /// If the number of elements to drop exceeds the number of elements in
@@ -918,7 +1069,7 @@ extension MutableSpan where Element: ~Copyable {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(droppingFirst k: Int) -> Self {
+  mutating public func _mutatingExtracting(droppingFirst k: Int) -> Self {
 #if compiler(>=5.3) && hasFeature(SendableCompletionHandlers)
     _precondition(k >= 0, "Can't drop a negative number of elements")
     let droppedCount = min(k, count)
@@ -929,6 +1080,29 @@ extension MutableSpan where Element: ~Copyable {
     return unsafe _overrideLifetime(newSpan, mutating: &self)
 #else
     fatalError("Unsupported compiler")
+#endif
+  }
+
+  @available(*, deprecated, renamed: "_mutatingExtracting(droppingFirst:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
+  mutating public func extracting(droppingFirst k: Int) -> Self {
+    _mutatingExtracting(droppingFirst: k)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(droppingFirst k: Int) -> Self {
+#if compiler(>=5.3) && hasFeature(SendableCompletionHandlers)
+    _precondition(k >= 0, "Can't drop a negative number of elements")
+    let droppedCount = min(k, count)
+    let offset = droppedCount * MemoryLayout<Element>.stride
+    let newStart = unsafe _pointer?.advanced(by: offset)
+    let newCount = count &- droppedCount
+    let newSpan = unsafe Self(_unchecked: newStart, count: newCount)
+    return unsafe _overrideLifetime(newSpan, copying: self)
+#else
+    fatalError("Unsupported compiler")
 #endif
   }
 }