[stdlib] rename MutableRawSpan.extracting functions

Author: glessard

stdlib/public/core/Span/MutableRawSpan.swift

@@ -482,13 +482,31 @@ extension MutableRawSpan {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
+  mutating public func _mutatingExtracting(_ bounds: Range<Int>) -> 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<Int>) -> Self {
+    _mutatingExtracting(bounds)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(_ bounds: Range<Int>) -> 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
@@ -509,12 +527,29 @@ extension MutableRawSpan {
   @unsafe
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(unchecked bounds: Range<Int>) -> Self {
+  mutating public func _mutatingExtracting(unchecked bounds: Range<Int>) -> Self {
     let newStart = unsafe _pointer?.advanced(by: bounds.lowerBound)
     let newSpan = unsafe Self(_unchecked: newStart, byteCount: bounds.count)
     return unsafe _overrideLifetime(newSpan, mutating: &self)
   }
 
+  @unsafe
+  @available(*, deprecated, renamed: "_mutatingExtracting(unchecked:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
+  mutating public func extracting(unchecked bounds: Range<Int>) -> Self {
+    unsafe _mutatingExtracting(unchecked: bounds)
+  }
+
+  @unsafe
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(unchecked bounds: Range<Int>) -> Self {
+    let newStart = unsafe _pointer?.advanced(by: bounds.lowerBound)
+    let newSpan = unsafe Self(_unchecked: newStart, byteCount: bounds.count)
+    return unsafe _overrideLifetime(newSpan, copying: self)
+  }
+
   /// Constructs a new span over the items within the supplied range of
   /// positions within this span.
   ///
@@ -530,10 +565,27 @@ extension MutableRawSpan {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
+  mutating public func _mutatingExtracting(
+    _ bounds: some RangeExpression<Int>
+  ) -> Self {
+    _mutatingExtracting(bounds.relative(to: byteOffsets))
+  }
+
+  @available(*, deprecated, renamed: "_mutatingExtracting(_:)")
+  @_alwaysEmitIntoClient
+  @lifetime(&self)
   mutating public func extracting(
     _ bounds: some RangeExpression<Int>
   ) -> Self {
-    extracting(bounds.relative(to: byteOffsets))
+    _mutatingExtracting(bounds)
+  }
+
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(
+    _ bounds: some RangeExpression<Int>
+  ) -> Self {
+    _consumingExtracting(bounds.relative(to: byteOffsets))
   }
 
   /// Constructs a new span over the items within the supplied range of
@@ -554,11 +606,35 @@ extension MutableRawSpan {
   @unsafe
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(unchecked bounds: ClosedRange<Int>) -> Self {
+  mutating public func _mutatingExtracting(
+    unchecked bounds: ClosedRange<Int>
+  ) -> 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<Int>
+  ) -> Self {
+    unsafe _mutatingExtracting(unchecked: bounds)
+  }
+
+  @unsafe
+  @_alwaysEmitIntoClient
+  @lifetime(copy self)
+  consuming public func _consumingExtracting(
+    unchecked bounds: ClosedRange<Int>
+  ) -> 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.
@@ -572,10 +648,23 @@ extension MutableRawSpan {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&self)
-  mutating public func extracting(_: UnboundedRange) -> Self {
+  mutating public func _mutatingExtracting(_: UnboundedRange) -> Self {
     let newSpan = unsafe Self(_unchecked: _pointer, byteCount: _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
@@ -600,7 +689,7 @@ extension MutableRawSpan {
   /// - 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, byteCount)
@@ -611,6 +700,26 @@ extension MutableRawSpan {
 #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, byteCount)
+    let newSpan = unsafe Self(_unchecked: _pointer, byteCount: 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
@@ -627,7 +736,7 @@ extension MutableRawSpan {
   /// - 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, byteCount)
@@ -639,6 +748,27 @@ extension MutableRawSpan {
 #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, byteCount)
+    let newCount = byteCount &- droppedCount
+    let newSpan = unsafe Self(_unchecked: _pointer, byteCount: 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.
   ///
@@ -656,12 +786,37 @@ extension MutableRawSpan {
   /// - Complexity: O(1)
   @_alwaysEmitIntoClient
   @lifetime(&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, byteCount)
+    let newStart = unsafe _pointer?.advanced(by: byteCount &- newCount)
+    let newSpan = unsafe Self(_unchecked: newStart, byteCount: newCount)
+    return unsafe _overrideLifetime(newSpan, mutating: &self)
+#else
+    fatalError("Unsupported compiler")
+#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, byteCount)
     let newStart = unsafe _pointer?.advanced(by: byteCount &- newCount)
     let newSpan = unsafe Self(_unchecked: newStart, byteCount: newCount)
     return unsafe _overrideLifetime(newSpan, copying: self)
+#else
+    fatalError("Unsupported compiler")
+#endif
   }
 
   /// Returns a span over all but the given number of initial elements.
@@ -680,7 +835,7 @@ extension MutableRawSpan {
   /// - 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 bytes")
     let droppedCount = min(k, byteCount)
@@ -690,6 +845,28 @@ extension MutableRawSpan {
     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 bytes")
+    let droppedCount = min(k, byteCount)
+    let newStart = unsafe _pointer?.advanced(by: droppedCount)
+    let newCount = byteCount &- droppedCount
+    let newSpan = unsafe Self(_unchecked: newStart, byteCount: newCount)
+    return unsafe _overrideLifetime(newSpan, copying: self)
+#else
+    fatalError("Unsupported compiler")
 #endif
   }
 }