Soundness

Author: Davidde94

Sources/RawStructuredFieldValues/ComponentTypes.swift

@@ -192,10 +192,10 @@ public struct InnerList: Hashable, SHSendable {
     }
 }
 
-extension String {
+public extension String {
     /// Whether this string is a valid structured headers token, or whether it would
     /// need to be stored in a structured headers string.
-    public var structuredHeadersIsValidToken: Bool {
+    var structuredHeadersIsValidToken: Bool {
         let view = self.utf8
 
         switch view.first {

Sources/RawStructuredFieldValues/Errors.swift

@@ -41,22 +41,22 @@ public struct StructuredHeaderError: Error, SHSendable {
     }
 }
 
-extension StructuredHeaderError {
-    public static let invalidTrailingBytes = StructuredHeaderError(.invalidTrailingBytes)
-    public static let invalidInnerList = StructuredHeaderError(.invalidInnerList)
-    public static let invalidItem = StructuredHeaderError(.invalidItem)
-    public static let invalidKey = StructuredHeaderError(.invalidKey)
-    public static let invalidIntegerOrDecimal = StructuredHeaderError(.invalidIntegerOrDecimal)
-    public static let invalidString = StructuredHeaderError(.invalidString)
-    public static let invalidByteSequence = StructuredHeaderError(.invalidByteSequence)
-    public static let invalidBoolean = StructuredHeaderError(.invalidBoolean)
-    public static let invalidToken = StructuredHeaderError(.invalidToken)
-    public static let invalidList = StructuredHeaderError(.invalidList)
-    public static let invalidDictionary = StructuredHeaderError(.invalidDictionary)
-    public static let missingKey = StructuredHeaderError(.missingKey)
-    public static let invalidTypeForItem = StructuredHeaderError(.invalidTypeForItem)
-    public static let integerOutOfRange = StructuredHeaderError(.integerOutOfRange)
-    public static let indexOutOfRange = StructuredHeaderError(.indexOutOfRange)
+public extension StructuredHeaderError {
+    static let invalidTrailingBytes = StructuredHeaderError(.invalidTrailingBytes)
+    static let invalidInnerList = StructuredHeaderError(.invalidInnerList)
+    static let invalidItem = StructuredHeaderError(.invalidItem)
+    static let invalidKey = StructuredHeaderError(.invalidKey)
+    static let invalidIntegerOrDecimal = StructuredHeaderError(.invalidIntegerOrDecimal)
+    static let invalidString = StructuredHeaderError(.invalidString)
+    static let invalidByteSequence = StructuredHeaderError(.invalidByteSequence)
+    static let invalidBoolean = StructuredHeaderError(.invalidBoolean)
+    static let invalidToken = StructuredHeaderError(.invalidToken)
+    static let invalidList = StructuredHeaderError(.invalidList)
+    static let invalidDictionary = StructuredHeaderError(.invalidDictionary)
+    static let missingKey = StructuredHeaderError(.missingKey)
+    static let invalidTypeForItem = StructuredHeaderError(.invalidTypeForItem)
+    static let integerOutOfRange = StructuredHeaderError(.integerOutOfRange)
+    static let indexOutOfRange = StructuredHeaderError(.indexOutOfRange)
 }
 
 extension StructuredHeaderError: Hashable {}

Sources/RawStructuredFieldValues/FieldParser.swift

@@ -25,9 +25,7 @@ public struct StructuredFieldValueParser<BaseData: RandomAccessCollection> where
     }
 }
 
-extension StructuredFieldValueParser: SHSendable where BaseData: SHSendable, BaseData.SubSequence: SHSendable {
-
-}
+extension StructuredFieldValueParser: SHSendable where BaseData: SHSendable, BaseData.SubSequence: SHSendable {}
 
 extension StructuredFieldValueParser {
     // Helper typealiases to avoid the explosion of generic parameters
@@ -519,10 +517,10 @@ extension RandomAccessCollection where Element == UInt8, SubSequence == Self {
     }
 }
 
-extension String {
+private extension String {
     // This is the slow path, so we never inline this.
     @inline(never)
-    fileprivate static func decodingEscapes<Bytes: RandomAccessCollection>(_ bytes: Bytes, escapes: Int) -> String where Bytes.Element == UInt8 {
+    static func decodingEscapes<Bytes: RandomAccessCollection>(_ bytes: Bytes, escapes: Int) -> String where Bytes.Element == UInt8 {
         // We assume the string is previously validated, so the escapes are easily removed. See the doc comment for
         // `StrippingStringEscapesCollection` for more details on what we're doing here.
         let unescapedBytes = StrippingStringEscapesCollection(bytes, escapes: escapes)

Sources/RawStructuredFieldValues/FieldSerializer.swift

@@ -23,14 +23,14 @@ public struct StructuredFieldValueSerializer: SHSendable {
     }
 }
 
-extension StructuredFieldValueSerializer {
+public extension StructuredFieldValueSerializer {
     /// Writes a structured dictionary header field value.
     ///
     /// - parameters:
     ///     - root: The dictionary object.
     /// - throws: If the dictionary could not be serialized.
     /// - returns: The bytes of the serialized header field value.
-    public mutating func writeDictionaryFieldValue(_ root: OrderedMap<String, ItemOrInnerList>) throws -> [UInt8] {
+    mutating func writeDictionaryFieldValue(_ root: OrderedMap<String, ItemOrInnerList>) throws -> [UInt8] {
         guard root.count > 0 else {
             return []
         }
@@ -48,7 +48,7 @@ extension StructuredFieldValueSerializer {
     ///     - root: The list object.
     /// - throws: If the list could not be serialized.
     /// - returns: The bytes of the serialized header field value.
-    public mutating func writeListFieldValue(_ list: [ItemOrInnerList]) throws -> [UInt8] {
+    mutating func writeListFieldValue(_ list: [ItemOrInnerList]) throws -> [UInt8] {
         guard list.count > 0 else {
             return []
         }
@@ -66,7 +66,7 @@ extension StructuredFieldValueSerializer {
     ///     - root: The item.
     /// - throws: If the item could not be serialized.
     /// - returns: The bytes of the serialized header field value.
-    public mutating func writeItemFieldValue(_ item: Item) throws -> [UInt8] {
+    mutating func writeItemFieldValue(_ item: Item) throws -> [UInt8] {
         defer {
             self.data.removeAll(keepingCapacity: true)
         }

Sources/RawStructuredFieldValues/OrderedMap.swift

@@ -35,7 +35,7 @@ public struct OrderedMap<Key, Value>: SHSendable where Key: Hashable {
     /// Warning! Unlike a regular dictionary, we do not promise this will be O(1)!
     public subscript(key: Key) -> Value? {
         get {
-            self.backing.first(where: { $0.key == key }).map { $0.value }
+            self.backing.first(where: { $0.key == key }).map(\.value)
         }
         set {
             if let existing = self.backing.firstIndex(where: { $0.key == key }) {
@@ -53,15 +53,15 @@ public struct OrderedMap<Key, Value>: SHSendable where Key: Hashable {
 
 // MARK: - Helper struct for storing elements
 
-extension OrderedMap {
+private extension OrderedMap {
     // This struct takes some explaining.
     //
     // We don't want to maintain too much code here. In particular, we'd like to have straightforward equatable and hashable
     // implementations. However, tuples aren't equatable or hashable. So we need to actually store something that is: a nominal
     // type. That's this!
     //
     // This existence of this struct is a pure implementation detail and not exposed to the user of the type.
-    fileprivate struct Entry {
+    struct Entry {
         var key: Key
         var value: Value
     }

Sources/RawStructuredFieldValues/PseudoDecimal.swift

@@ -182,8 +182,8 @@ extension PseudoDecimal: ExpressibleByFloatLiteral {
     }
 }
 
-extension String {
-    public init(_ decimal: PseudoDecimal) {
+public extension String {
+    init(_ decimal: PseudoDecimal) {
         var local = decimal
         local.canonicalise()
 
@@ -216,8 +216,8 @@ extension String {
 }
 
 // Swift Numerics would let us do this for all the floating point types.
-extension Double {
-    public init(_ pseudoDecimal: PseudoDecimal) {
+public extension Double {
+    init(_ pseudoDecimal: PseudoDecimal) {
         self = Double(pseudoDecimal.mantissa) * pow(10, Double(pseudoDecimal.exponent))
     }
 }

Sources/StructuredFieldValues/Decoder/StructuredFieldValueDecoder.swift

@@ -23,9 +23,9 @@ public struct StructuredFieldValueDecoder: SHSendable {
     public init() {}
 }
 
-extension StructuredFieldValueDecoder {
+public extension StructuredFieldValueDecoder {
     /// A strategy that should be used to map coding keys to wire format keys.
-    public struct KeyDecodingStrategy: Hashable, SHSendable {
+    struct KeyDecodingStrategy: Hashable, SHSendable {
         fileprivate enum Base: Hashable {
             case lowercase
         }
@@ -184,9 +184,9 @@ extension _StructuredFieldDecoder: Decoder {
         // We have single value containers for items and bareItems.
         switch self.currentElement! {
         case .item(let item):
-            return BareItemDecoder(item.bareItem, codingPath: self._codingStack.map { $0.key })
+            return BareItemDecoder(item.bareItem, codingPath: self._codingStack.map(\.key))
         case .bareItem(let bareItem):
-            return BareItemDecoder(bareItem, codingPath: self._codingStack.map { $0.key })
+            return BareItemDecoder(bareItem, codingPath: self._codingStack.map(\.key))
         case .dictionary, .list, .innerList, .bareInnerList, .parameters:
             throw StructuredHeaderError.invalidTypeForItem
         }
@@ -217,9 +217,9 @@ extension _StructuredFieldDecoder: Decoder {
     }
 }
 
-extension _StructuredFieldDecoder {
+private extension _StructuredFieldDecoder {
     /// The basic elements that make up a Structured Header
-    fileprivate enum Element {
+    enum Element {
         case dictionary(OrderedMap<String, ItemOrInnerList>)
         case list([ItemOrInnerList])
         case item(Item)
@@ -314,6 +314,6 @@ extension _StructuredFieldDecoder {
 
     /// The element at the current head of the coding stack.
     private var currentElement: Element? {
-        self._codingStack.last.map { $0.element }
+        self._codingStack.last.map(\.element)
     }
 }

Sources/StructuredFieldValues/Encoder/StructuredFieldKeyedEncodingContainer.swift

@@ -94,7 +94,7 @@ extension StructuredFieldKeyedEncodingContainer: KeyedEncodingContainerProtocol
     }
 
     mutating func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type, forKey key: Key) -> KeyedEncodingContainer<NestedKey> where NestedKey: CodingKey {
-        return self.encoder.container(keyedBy: keyType)
+        self.encoder.container(keyedBy: keyType)
     }
 
     mutating func nestedUnkeyedContainer(forKey key: Key) -> UnkeyedEncodingContainer {

Sources/StructuredFieldValues/Encoder/StructuredFieldUnkeyedEncodingContainer.swift

@@ -98,7 +98,7 @@ extension StructuredFieldUnkeyedEncodingContainer: UnkeyedEncodingContainer {
     }
 
     mutating func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> where NestedKey: CodingKey {
-        return self.encoder.container(keyedBy: keyType)
+        self.encoder.container(keyedBy: keyType)
     }
 
     mutating func nestedUnkeyedContainer() -> UnkeyedEncodingContainer {

Sources/StructuredFieldValues/Encoder/StructuredFieldValueEncoder.swift

@@ -22,9 +22,9 @@ public struct StructuredFieldValueEncoder: SHSendable {
     public init() {}
 }
 
-extension StructuredFieldValueEncoder {
+public extension StructuredFieldValueEncoder {
     /// A strategy that should be used to map coding keys to wire format keys.
-    public struct KeyEncodingStrategy: Hashable, SHSendable {
+    struct KeyEncodingStrategy: Hashable, SHSendable {
         fileprivate enum Base: Hashable {
             case lowercase
         }
@@ -197,7 +197,7 @@ extension _StructuredFieldEncoder: Encoder {
     }
 
     func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {
-        return KeyedEncodingContainer(StructuredFieldKeyedEncodingContainer(encoder: self))
+        KeyedEncodingContainer(StructuredFieldKeyedEncodingContainer(encoder: self))
     }
 
     func unkeyedContainer() -> UnkeyedEncodingContainer {
@@ -924,8 +924,8 @@ extension _StructuredFieldEncoder {
     }
 }
 
-extension Item {
-    fileprivate init(_ partialItem: _StructuredFieldEncoder.NodeType.PartialItem) {
+private extension Item {
+    init(_ partialItem: _StructuredFieldEncoder.NodeType.PartialItem) {
         self.init(bareItem: partialItem.bareItem!, parameters: partialItem.parameters)
     }
 }

Tests/StructuredFieldValuesTests/StructuredFieldParserTests.swift

@@ -96,9 +96,10 @@ final class StructuredFieldParserTests: XCTestCase {
 
     private func _validateInnerList(_ innerList: InnerList, against schema: JSONSchema, fixtureName: String) throws {
         guard case .array(let arrayElements) = schema,
-            arrayElements.count == 2,
-            case .some(.array(let expectedItems)) = arrayElements.first,
-            let expectedParameters = arrayElements.last else {
+              arrayElements.count == 2,
+              case .some(.array(let expectedItems)) = arrayElements.first,
+              let expectedParameters = arrayElements.last
+        else {
             XCTFail("\(fixtureName): Unexpected inner list: got \(innerList), expected \(schema)")
             return
         }