Adopt strict memory safety annotations in BinaryParsing

Package.swift

@@ -40,6 +40,7 @@ let package = Package(
         .enableExperimentalFeature("Span"),
         .enableExperimentalFeature("ValueGenerics"),
         .enableExperimentalFeature("LifetimeDependence"),
+        .strictMemorySafety(),
       ]
     ),
     //    .target(

Sources/BinaryParsing/Operations/OptionalOperations.swift

@@ -20,7 +20,6 @@ extension Collection {
 
   @inlinable
   public subscript(ifInBounds range: Range<Index>) -> SubSequence? {
-    let bounds = startIndex...endIndex
     guard range.lowerBound >= startIndex, range.upperBound <= endIndex
     else { return nil }
     return self[range]

Sources/BinaryParsing/Parser Types/ParserSource.swift

@@ -50,8 +50,8 @@ extension RandomAccessCollection<UInt8> {
   ) throws(ThrownParsingError) -> T? {
     #if canImport(Foundation)
     if let data = self as? Foundation.Data {
-      let result = data.withUnsafeBytes { buffer in
-        var span = ParserSpan(_unsafeBytes: buffer)
+      let result = unsafe data.withUnsafeBytes { buffer in
+        var span = unsafe ParserSpan(_unsafeBytes: buffer)
         return Result<T, ThrownParsingError> { try body(&span) }
       }
       switch result {
@@ -63,7 +63,7 @@ extension RandomAccessCollection<UInt8> {
 
     let result = self.withContiguousStorageIfAvailable { buffer in
       let rawBuffer = UnsafeRawBufferPointer(buffer)
-      var span = ParserSpan(_unsafeBytes: rawBuffer)
+      var span = unsafe ParserSpan(_unsafeBytes: rawBuffer)
       return Result<T, ThrownParsingError> { try body(&span) }
     }
     switch result {
@@ -118,8 +118,8 @@ extension Data: ParserSpanProvider {
   public func withParserSpan<T, E>(
     _ body: (inout ParserSpan) throws(E) -> T
   ) throws(E) -> T {
-    let result = withUnsafeBytes { buffer in
-      var span = ParserSpan(_unsafeBytes: buffer)
+    let result = unsafe withUnsafeBytes { buffer in
+      var span = unsafe ParserSpan(_unsafeBytes: buffer)
       return Result<T, E> { () throws(E) in try body(&span) }
     }
     switch result {
@@ -134,8 +134,8 @@ extension [UInt8]: ParserSpanProvider {
   public func withParserSpan<T, E>(
     _ body: (inout ParserSpan) throws(E) -> T
   ) throws(E) -> T {
-    let result = self.withUnsafeBytes { rawBuffer in
-      var span = ParserSpan(_unsafeBytes: rawBuffer)
+    let result = unsafe self.withUnsafeBytes { rawBuffer in
+      var span = unsafe ParserSpan(_unsafeBytes: rawBuffer)
       return Result<T, E> { () throws(E) in try body(&span) }
     }
     switch result {
@@ -149,8 +149,8 @@ extension ArraySlice<UInt8>: ParserSpanProvider {
   public func withParserSpan<T, E>(
     _ body: (inout ParserSpan) throws(E) -> T
   ) throws(E) -> T {
-    let result = self.withUnsafeBytes { rawBuffer in
-      var span = ParserSpan(_unsafeBytes: rawBuffer)
+    let result = unsafe self.withUnsafeBytes { rawBuffer in
+      var span = unsafe ParserSpan(_unsafeBytes: rawBuffer)
       return Result<T, E> { () throws(E) in try body(&span) }
     }
     switch result {

Sources/BinaryParsing/Parser Types/ParserSpan.swift

@@ -29,10 +29,11 @@ public struct ParserSpan: ~Escapable, BitwiseCopyable {
     self._upperBound = _bytes.byteCount
   }
 
+  @unsafe
   @inlinable
   @lifetime(borrow buffer)
   public init(_unsafeBytes buffer: UnsafeRawBufferPointer) {
-    self._bytes = RawSpan(_unsafeBytes: buffer)
+    self._bytes = unsafe RawSpan(_unsafeBytes: buffer)
     self._lowerBound = 0
     self._upperBound = _bytes.byteCount
   }
@@ -111,7 +112,7 @@ extension ParserSpan {
   subscript(offset i: Int) -> UInt8 {
     precondition(i >= 0)
     precondition(i < count)
-    return _bytes.unsafeLoad(
+    return unsafe _bytes.unsafeLoad(
       fromUncheckedByteOffset: _lowerBound &+ i,
       as: UInt8.self)
   }
@@ -124,10 +125,10 @@ extension ParserSpan {
   public func withUnsafeBytes<T, E>(
     _ body: (UnsafeRawBufferPointer) throws(E) -> T
   ) throws(E) -> T {
-    try _bytes.withUnsafeBytes { (fullBuffer) throws(E) in
-      let buffer = UnsafeRawBufferPointer(
+    try unsafe _bytes.withUnsafeBytes { (fullBuffer) throws(E) in
+      let buffer = unsafe UnsafeRawBufferPointer(
         rebasing: fullBuffer[_lowerBound..<_upperBound])
-      return try body(buffer)
+      return try unsafe body(buffer)
     }
   }
 }
@@ -153,25 +154,27 @@ extension ParserSpan {
   @discardableResult
   mutating func consume() -> UInt8? {
     guard !isEmpty else { return nil }
-    return consumeUnchecked()
+    return unsafe consumeUnchecked()
   }
 
+  @unsafe
   @inlinable
   @lifetime(copy self)
   mutating func consumeUnchecked(type: UInt8.Type = UInt8.self) -> UInt8 {
     defer { _lowerBound &+= 1 }
-    return _bytes.unsafeLoad(
+    return unsafe _bytes.unsafeLoad(
       fromUncheckedByteOffset: _lowerBound,
       as: UInt8.self)
   }
 
+  @unsafe
   @inlinable
   @lifetime(copy self)
   mutating func consumeUnchecked<T: FixedWidthInteger & BitwiseCopyable>(
     type: T.Type
   ) -> T {
     defer { _lowerBound += MemoryLayout<T>.stride }
-    return _bytes.unsafeLoadUnaligned(
+    return unsafe _bytes.unsafeLoadUnaligned(
       fromUncheckedByteOffset: _lowerBound,
       as: T.self)
   }

Sources/BinaryParsing/Parsers/Array.swift

@@ -16,8 +16,8 @@ extension Array where Element == UInt8 {
     throws(ParsingError)
   {
     defer { _ = input.divide(atOffset: input.count) }
-    self = input.withUnsafeBytes { buffer in
-      Array(buffer)
+    self = unsafe input.withUnsafeBytes { buffer in
+      unsafe Array(buffer)
     }
   }
 
@@ -27,8 +27,8 @@ extension Array where Element == UInt8 {
     throws(ParsingError)
   {
     let slice = try input._divide(atByteOffset: byteCount)
-    self = slice.withUnsafeBytes { buffer in
-      Array(buffer)
+    self = unsafe slice.withUnsafeBytes { buffer in
+      unsafe Array(buffer)
     }
   }
 }