Revert fastRebase implementation

Sources/NIOCore/ByteBuffer-aux.swift

@@ -39,7 +39,7 @@ extension ByteBuffer {
             // this is not technically correct because we shouldn't just bind
             // the memory to `UInt8` but it's not a real issue either and we
             // need to work around https://bugs.swift.org/browse/SR-9604
-            [UInt8](UnsafeRawBufferPointer(fastRebase: ptr[range]).bindMemory(to: UInt8.self))
+            [UInt8](UnsafeRawBufferPointer(rebasing: ptr[range]).bindMemory(to: UInt8.self))
         }
     }
 
@@ -205,7 +205,10 @@ extension ByteBuffer {
         }
         return self.withUnsafeReadableBytes { pointer in
             assert(range.lowerBound >= 0 && (range.upperBound - range.lowerBound) <= pointer.count)
-            return String(decoding: UnsafeRawBufferPointer(fastRebase: pointer[range]), as: Unicode.UTF8.self)
+            return String(
+                decoding: UnsafeRawBufferPointer(rebasing: pointer[range]),
+                as: Unicode.UTF8.self
+            )
         }
     }
 
@@ -329,7 +332,7 @@ extension ByteBuffer {
         self.withVeryUnsafeMutableBytes { destCompleteStorage in
             assert(destCompleteStorage.count >= index + allBytesCount)
             let dest = destCompleteStorage[index..<index + allBytesCount]
-            dispatchData.copyBytes(to: .init(fastRebase: dest), count: dest.count)
+            dispatchData.copyBytes(to: .init(rebasing: dest), count: dest.count)
         }
         return allBytesCount
     }
@@ -348,7 +351,7 @@ extension ByteBuffer {
             return nil
         }
         return self.withUnsafeReadableBytes { pointer in
-            DispatchData(bytes: UnsafeRawBufferPointer(fastRebase: pointer[range]))
+            DispatchData(bytes: UnsafeRawBufferPointer(rebasing: pointer[range]))
         }
     }
 
@@ -497,7 +500,7 @@ extension ByteBuffer {
         precondition(count >= 0, "Can't write fewer than 0 bytes")
         self.reserveCapacity(index + count)
         self.withVeryUnsafeMutableBytes { pointer in
-            let dest = UnsafeMutableRawBufferPointer(fastRebase: pointer[index..<index + count])
+            let dest = UnsafeMutableRawBufferPointer(rebasing: pointer[index..<index + count])
             _ = dest.initializeMemory(as: UInt8.self, repeating: byte)
         }
         return count

Sources/NIOCore/ByteBuffer-core.swift

@@ -503,7 +503,9 @@ public struct ByteBuffer {
 
     @inlinable
     mutating func _setBytesAssumingUniqueBufferAccess(_ bytes: UnsafeRawBufferPointer, at index: _Index) {
-        let targetPtr = UnsafeMutableRawBufferPointer(fastRebase: self._slicedStorageBuffer.dropFirst(Int(index)))
+        let targetPtr = UnsafeMutableRawBufferPointer(
+            rebasing: self._slicedStorageBuffer.dropFirst(Int(index))
+        )
         targetPtr.copyMemory(from: bytes)
     }
 
@@ -515,7 +517,7 @@ public struct ByteBuffer {
         func ensureCapacityAndReturnStorageBase(capacity: Int) -> UnsafeMutablePointer<UInt8> {
             self._ensureAvailableCapacity(_Capacity(capacity), at: index)
             let newBytesPtr = UnsafeMutableRawBufferPointer(
-                fastRebase: self._slicedStorageBuffer[Int(index)..<Int(index) + Int(capacity)]
+                rebasing: self._slicedStorageBuffer[Int(index)..<Int(index) + Int(capacity)]
             )
             return newBytesPtr.bindMemory(to: UInt8.self).baseAddress!
         }
@@ -659,7 +661,7 @@ public struct ByteBuffer {
         self._copyStorageAndRebaseIfNeeded()
         // this is safe because we always know that readerIndex >= writerIndex
         let range = Range<Int>(uncheckedBounds: (lower: self.readerIndex, upper: self.writerIndex))
-        return try body(.init(fastRebase: self._slicedStorageBuffer[range]))
+        return try body(.init(rebasing: self._slicedStorageBuffer[range]))
     }
 
     /// Yields the bytes currently writable (`bytesWritable` = `capacity` - `writerIndex`). Before reading those bytes you must first
@@ -677,7 +679,7 @@ public struct ByteBuffer {
         _ body: (UnsafeMutableRawBufferPointer) throws -> T
     ) rethrows -> T {
         self._copyStorageAndRebaseIfNeeded()
-        return try body(.init(fastRebase: self._slicedStorageBuffer.dropFirst(self.writerIndex)))
+        return try body(.init(rebasing: self._slicedStorageBuffer.dropFirst(self.writerIndex)))
     }
 
     /// This vends a pointer of the `ByteBuffer` at the `writerIndex` after ensuring that the buffer has at least `minimumWritableBytes` of writable bytes available.
@@ -748,7 +750,7 @@ public struct ByteBuffer {
     public func withUnsafeReadableBytes<T>(_ body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T {
         // This is safe, writerIndex >= readerIndex
         let range = Range<Int>(uncheckedBounds: (lower: self.readerIndex, upper: self.writerIndex))
-        return try body(.init(fastRebase: self._slicedStorageBuffer[range]))
+        return try body(.init(rebasing: self._slicedStorageBuffer[range]))
     }
 
     /// Yields a buffer pointer containing this `ByteBuffer`'s readable bytes. You may hold a pointer to those bytes
@@ -769,7 +771,7 @@ public struct ByteBuffer {
         let storageReference: Unmanaged<AnyObject> = Unmanaged.passUnretained(self._storage)
         // This is safe, writerIndex >= readerIndex
         let range = Range<Int>(uncheckedBounds: (lower: self.readerIndex, upper: self.writerIndex))
-        return try body(.init(fastRebase: self._slicedStorageBuffer[range]), storageReference)
+        return try body(.init(rebasing: self._slicedStorageBuffer[range]), storageReference)
     }
 
     /// See `withUnsafeReadableBytesWithStorageManagement` and `withVeryUnsafeBytes`.
@@ -1120,7 +1122,7 @@ extension ByteBuffer {
         self._ensureAvailableCapacity(_Capacity(length), at: _toIndex(toIndex))
         self.withVeryUnsafeMutableBytes { ptr in
             let srcPtr = UnsafeRawBufferPointer(start: ptr.baseAddress!.advanced(by: fromIndex), count: length)
-            let targetPtr = UnsafeMutableRawBufferPointer(fastRebase: ptr.dropFirst(toIndex))
+            let targetPtr = UnsafeMutableRawBufferPointer(rebasing: ptr.dropFirst(toIndex))
             targetPtr.copyMemory(from: srcPtr)
         }
 

Sources/NIOCore/ByteBuffer-int.swift

@@ -67,7 +67,7 @@ extension ByteBuffer {
         return self.withUnsafeReadableBytes { ptr in
             var value: T = 0
             withUnsafeMutableBytes(of: &value) { valuePtr in
-                valuePtr.copyMemory(from: UnsafeRawBufferPointer(fastRebase: ptr[range]))
+                valuePtr.copyMemory(from: UnsafeRawBufferPointer(rebasing: ptr[range]))
             }
             return _toEndianness(value: value, endianness: endianness)
         }

Sources/NIOPosix/ControlMessage.swift

@@ -79,7 +79,9 @@ struct UnsafeControlMessageStorage: Collection {
     /// Get the part of the buffer for use with a message.
     public subscript(position: Int) -> UnsafeMutableRawBufferPointer {
         UnsafeMutableRawBufferPointer(
-            fastRebase: self.buffer[(position * self.bytesPerMessage)..<((position + 1) * self.bytesPerMessage)]
+            rebasing: self.buffer[
+                (position * self.bytesPerMessage)..<((position + 1) * self.bytesPerMessage)
+            ]
         )
     }
 
@@ -316,7 +318,9 @@ struct UnsafeOutboundControlBytes {
         type: CInt,
         payload: PayloadType
     ) {
-        let writableBuffer = UnsafeMutableRawBufferPointer(fastRebase: self.controlBytes[writePosition...])
+        let writableBuffer = UnsafeMutableRawBufferPointer(
+            rebasing: self.controlBytes[writePosition...]
+        )
 
         let requiredSize = NIOBSDSocketControlMessage.space(payloadSize: MemoryLayout.stride(ofValue: payload))
         precondition(writableBuffer.count >= requiredSize, "Insufficient size for cmsghdr and data")
@@ -342,7 +346,7 @@ struct UnsafeOutboundControlBytes {
         if writePosition == 0 {
             return UnsafeMutableRawBufferPointer(start: nil, count: 0)
         }
-        return UnsafeMutableRawBufferPointer(fastRebase: self.controlBytes[0..<self.writePosition])
+        return UnsafeMutableRawBufferPointer(rebasing: self.controlBytes[0..<self.writePosition])
     }
 
 }