[span] readability improvements

Author: glessard

stdlib/public/core/Span/RawSpan.swift

@@ -179,7 +179,7 @@ extension RawSpan {
   ) {
     _precondition(count >= 0, "Count must not be negative")
     self.init(
-      _unchecked: pointer, byteCount: count*MemoryLayout<T>.stride
+      _unchecked: pointer, byteCount: count * MemoryLayout<T>.stride
     )
   }
 
@@ -601,8 +601,8 @@ extension RawSpan {
   @_alwaysEmitIntoClient
   public func _extracting(droppingLast k: Int) -> Self {
     _precondition(k >= 0, "Can't drop a negative number of elements.")
-    let dc = min(k, byteCount)
-    return Self(_unchecked: _pointer, byteCount: byteCount&-dc)
+    let droppedCount = min(k, byteCount)
+    return Self(_unchecked: _pointer, byteCount: byteCount &- droppedCount)
   }
 
   /// Returns a span containing the trailing bytes of the span,
@@ -625,7 +625,7 @@ extension RawSpan {
   public func _extracting(last maxLength: Int) -> Self {
     _precondition(maxLength >= 0, "Can't have a suffix of negative length.")
     let newCount = min(maxLength, byteCount)
-    let newStart = _pointer?.advanced(by: byteCount&-newCount)
+    let newStart = _pointer?.advanced(by: byteCount &- newCount)
     return Self(_unchecked: newStart, byteCount: newCount)
   }
 
@@ -647,8 +647,8 @@ extension RawSpan {
   @_alwaysEmitIntoClient
   public func _extracting(droppingFirst k: Int) -> Self {
     _precondition(k >= 0, "Can't drop a negative number of elements.")
-    let dc = min(k, byteCount)
-    let newStart = _pointer?.advanced(by: dc)
-    return Self(_unchecked: newStart, byteCount: byteCount&-dc)
+    let droppedCount = min(k, byteCount)
+    let newStart = _pointer?.advanced(by: droppedCount)
+    return Self(_unchecked: newStart, byteCount: byteCount &- droppedCount)
   }
 }

stdlib/public/core/Span/Span.swift

@@ -63,7 +63,7 @@ extension Span where Element: ~Copyable {
   ) {
     _precondition(
       ((Int(bitPattern: buffer.baseAddress) &
-        (MemoryLayout<Element>.alignment&-1)) == 0),
+        (MemoryLayout<Element>.alignment &- 1)) == 0),
       "baseAddress must be properly aligned to access Element"
     )
     self.init(_unchecked: buffer.baseAddress, count: buffer.count)
@@ -102,11 +102,11 @@ extension Span where Element: ~Copyable {
   @_alwaysEmitIntoClient
   @lifetime(immortal)
   public init(
-    _unsafeStart start: UnsafePointer<Element>,
+    _unsafeStart pointer: UnsafePointer<Element>,
     count: Int
   ) {
     _precondition(count >= 0, "Count must not be negative")
-    self.init(_unsafeElements: .init(start: start, count: count))
+    self.init(_unsafeElements: .init(start: pointer, count: count))
   }
 }
 
@@ -177,12 +177,14 @@ extension Span where Element: BitwiseCopyable {
   ) {
     _precondition(
       ((Int(bitPattern: buffer.baseAddress) &
-        (MemoryLayout<Element>.alignment&-1)) == 0),
+        (MemoryLayout<Element>.alignment &- 1)) == 0),
       "baseAddress must be properly aligned to access Element"
     )
     let (byteCount, stride) = (buffer.count, MemoryLayout<Element>.stride)
     let (count, remainder) = byteCount.quotientAndRemainder(dividingBy: stride)
-    _precondition(remainder == 0, "Span must contain a whole number of elements")
+    _precondition(
+      remainder == 0, "Span must contain a whole number of elements"
+    )
     self.init(_unchecked: buffer.baseAddress, count: count)
   }
 
@@ -428,10 +430,13 @@ extension Span where Element: ~Copyable {
   public subscript(unchecked position: Index) -> Element {
     //FIXME: change to unsafeRawAddress or unsafeAddress when ready
     _read {
-      let element = _start().advanced(by: position&*MemoryLayout<Element>.stride)
-      let binding = Builtin.bindMemory(element._rawValue, count._builtinWordValue, Element.self)
-      defer { Builtin.rebindMemory(element._rawValue, binding) }
-      yield UnsafePointer<Element>(element._rawValue).pointee
+      let elementOffset = position &* MemoryLayout<Element>.stride
+      let address = _start().advanced(by: elementOffset)
+      let binding = Builtin.bindMemory(
+        address._rawValue, 1._builtinWordValue, Element.self
+      )
+      defer { Builtin.rebindMemory(address._rawValue, binding) }
+      yield UnsafePointer<Element>(address._rawValue).pointee
     }
   }
 }
@@ -471,7 +476,8 @@ extension Span where Element: BitwiseCopyable {
   @_alwaysEmitIntoClient
   public subscript(unchecked position: Index) -> Element {
     get {
-      let address = _start().advanced(by: position&*MemoryLayout<Element>.stride)
+      let elementOffset = position &* MemoryLayout<Element>.stride
+      let address = _start().advanced(by: elementOffset)
       return address.loadUnaligned(as: Element.self)
     }
   }
@@ -525,7 +531,7 @@ extension Span where Element: ~Copyable {
   @unsafe
   @_alwaysEmitIntoClient
   public func _extracting(unchecked bounds: Range<Index>) -> Self {
-    let delta = bounds.lowerBound&*MemoryLayout<Element>.stride
+    let delta = bounds.lowerBound &* MemoryLayout<Element>.stride
     return Span(_unchecked: _pointer?.advanced(by: delta), count: bounds.count)
   }
 
@@ -676,8 +682,8 @@ extension Span where Element: ~Copyable {
     }
     let start = _start()
     let stride = MemoryLayout<Element>.stride
-    let spanEnd = spanStart + stride&*span._count
-    if spanStart < start || spanEnd > (start + stride&*_count) { return nil }
+    let spanEnd = spanStart + stride &* span._count
+    if spanStart < start || spanEnd > (start + stride &* _count) { return nil }
     let byteOffset = start.distance(to: spanStart)
     let (lower, r) = byteOffset.quotientAndRemainder(dividingBy: stride)
     guard r == 0 else { return nil }
@@ -732,7 +738,7 @@ extension Span where Element: ~Copyable {
   public func _extracting(droppingLast k: Int) -> Self {
     _precondition(k >= 0, "Can't drop a negative number of elements.")
     let droppedCount = min(k, count)
-    return Self(_unchecked: _pointer, count: count&-droppedCount)
+    return Self(_unchecked: _pointer, count: count &- droppedCount)
   }
 
   /// Returns a span containing the final elements of the span,
@@ -755,7 +761,8 @@ extension Span where Element: ~Copyable {
   public func _extracting(last maxLength: Int) -> Self {
     _precondition(maxLength >= 0, "Can't have a suffix of negative length.")
     let newCount = min(maxLength, count)
-    let newStart = _pointer?.advanced(by: (count&-newCount)*MemoryLayout<Element>.stride)
+    let offset = (count &- newCount) * MemoryLayout<Element>.stride
+    let newStart = _pointer?.advanced(by: offset)
     return Self(_unchecked: newStart, count: newCount)
   }
 
@@ -778,7 +785,8 @@ extension Span where Element: ~Copyable {
   public func _extracting(droppingFirst k: Int) -> Self {
     _precondition(k >= 0, "Can't drop a negative number of elements.")
     let droppedCount = min(k, count)
-    let newStart = _pointer?.advanced(by: droppedCount*MemoryLayout<Element>.stride)
-    return Self(_unchecked: newStart, count: count&-droppedCount)
+    let offset = droppedCount * MemoryLayout<Element>.stride
+    let newStart = _pointer?.advanced(by: offset)
+    return Self(_unchecked: newStart, count: count &- droppedCount)
   }
 }