Merge branch 'main' into enable_MemberImportVisibility_check

Author: glbrntt

README.md

@@ -6,19 +6,19 @@ Provides parsing and serialization facilities for structured header field values
 
 ## About Structured Header Field Values
 
-HTTP Structured Header Field Values are a HTTP extension recorded in [RFC 8941](https://www.rfc-editor.org/rfc/rfc8941.html). They provide a set of data types and algorithms for handling HTTP header field values in a consistent way, allowing a single parser and serializer to handle a wide range of header field values.
+HTTP Structured Header Field Values are a HTTP extension recorded in [RFC 9651](https://www.ietf.org/rfc/rfc9651.html). They provide a set of data types and algorithms for handling HTTP header field values in a consistent way, allowing a single parser and serializer to handle a wide range of header field values.
 
 ## Swift HTTP Structured Header Field Values
 
-This package provides a parser and serializer that implement RFC 8941. They are entirely complete, able to handle all valid HTTP structured header field values. This package also provides `Encoder` and `Decoder` objects for working with Codable in Swift. This allows rapid prototyping and experimentation with HTTP structured header field values, as well as interaction with the wider Swift Codable community.
+This package provides a parser and serializer that implement RFC 9651. They are entirely complete, able to handle all valid HTTP structured header field values. This package also provides `Encoder` and `Decoder` objects for working with Codable in Swift. This allows rapid prototyping and experimentation with HTTP structured header field values, as well as interaction with the wider Swift Codable community.
 
 This package provides two top-level modules: `StructuredFieldValues` and `RawStructuredFieldValues`.
 
 The base module, `RawStructuredFieldValues`, provides a low-level implementation of a serializer and parser. Both of these have been written to avoid using Foundation, making them suitable for a range of use-cases where Foundation is not available. They rely entirely on the Swift standard library and are implemented as generically as possible. One of the limitations due to the absence of Foundation is that this interface is not capable of performing Base64 encoding or decoding: users are free to bring whatever encoder and decoder they choose to use.
 
 This API is low-level, exposing the raw parse tree as the format for the serializer and parser. This allows high-performance and high-flexibility parsing and serialization, at the cost of being verbose and complex. Users are required to understand the structured header format and to operate the slightly awkward types, but maximal fidelity is retained and the performance overhead is low.
 
-The upper-level module, `StructuredFieldValues`, brings along the `Encoder` and `Decoder` and also adds a dependency on Foundation. This Foundation dependency is necessary to correctly handle the base64 formatting, as well as to provide a good natural container for binary data: `Data`. This interface is substantially friendlier and easier to work with, using Swift's `Codable` support to provide a great user experience.
+The upper-level module, `StructuredFieldValues`, brings along the `Encoder` and `Decoder` and also adds a dependency on Foundation. This Foundation dependency is necessary to correctly handle the base64 formatting, as well as to provide a good natural container for binary data: `Data`, and for dates: `Date`. This interface is substantially friendlier and easier to work with, using Swift's `Codable` support to provide a great user experience.
 
 In most cases users should prefer to use `StructuredFieldValues` unless they know they need the performance advantages of `RawStructuredFieldValues`. The experience will be much better.
 
@@ -56,12 +56,12 @@ let encoder = StructuredFieldValueEncoder()
 let serialized = try encoder.encode(AcceptCH(items: ["Sec-CH-Example", "Sec-CH-Example-2"]))
 ```
 
-However, structured header field values can be substantially more complex. Structured header fields can make use of 4 containers and 6 base item types. The containers are:
+However, structured header field values can be substantially more complex. Structured header fields can make use of 4 containers and 8 base item types. The containers are:
 
 1. Dictionaries. These are top-level elements and associate token keys with values. The values may be items, or may be inner lists, and each value may also have parameters associated with them. `StructuredFieldValues` can model dictionaries as either Swift objects (where the property names are dictionary keys).
 2. Lists. These are top-level elements, providing a sequence of items or inner lists. Each item or inner list may have parameters associated with them. `StructuredFieldValues` models these as Swift objects with one key, `items`, that must be a collection of entries.
 3. Inner Lists. These are lists that may be sub-entries of a dictionary or a list. The list entries are items, which may have parameters associated with them: additionally, an inner list may have parameters associated with itself as well. `StructuredFieldValues` models these as either Swift `Array`s _or_, if it's important to extract parameters, as a two-field Swift `struct` where one field is called `items` and contains an `Array`, and other field is called `parameters` and contains a dictionary.
-4. Parameters. Parameters associated token keys with items without parameters. These are used to store metadata about objects within a field. `StructuredFieldValues` models these as either Swift objects (where the property names are the parameter keys) or as Swift dictionaries.
+4. Parameters. Parameters associate token keys with items without parameters. These are used to store metadata about objects within a field. `StructuredFieldValues` models these as either Swift objects (where the property names are the parameter keys) or as Swift dictionaries.
 
 The base types are:
 
@@ -71,6 +71,8 @@ The base types are:
 4. Tokens. `StructuredFieldValues` models these as Swift's `String` type, where the range of characters is restricted.
 5. Strings. `StructuredFieldValues` models these as Swift's `String` type.
 6. Binary data. `StructuredFieldValues` models this as Foundation's `Data` type.
+7. Dates. `StructuredFieldValues` models these as Foundation's `Date` type.
+8. Display strings. `StructuredFieldValues` models these as the `DisplayString` type which it provides.
 
 For any Structured Header Field Value Item, the item may either be represented directly by the appropriate type, or by a Swift struct with two properties: `item` and `parameters`. This latter mode is how parameters on a given item may be captured.
 

Sources/RawStructuredFieldValues/ComponentTypes.swift

@@ -94,7 +94,7 @@ extension BareItem {
             self = .bool(b)
 
         case .integer(let i):
-            self = .integer(i)
+            self = .integer(Int(i))
 
         case .decimal(let d):
             self = .decimal(d)
@@ -126,7 +126,7 @@ public enum RFC9651BareItem: Sendable {
     case bool(Bool)
 
     /// An integer item.
-    case integer(Int)
+    case integer(Int64)
 
     /// A decimal item.
     case decimal(PseudoDecimal)
@@ -142,7 +142,7 @@ public enum RFC9651BareItem: Sendable {
     case token(String)
 
     /// A date item.
-    case date(Int)
+    case date(Int64)
 
     /// A display string item.
     case displayString(String)
@@ -155,7 +155,7 @@ extension RFC9651BareItem: ExpressibleByBooleanLiteral {
 }
 
 extension RFC9651BareItem: ExpressibleByIntegerLiteral {
-    public init(integerLiteral value: Int) {
+    public init(integerLiteral value: Int64) {
         self = .integer(value)
     }
 }
@@ -184,7 +184,7 @@ extension RFC9651BareItem {
             self = .bool(b)
 
         case .integer(let i):
-            self = .integer(i)
+            self = .integer(Int64(i))
 
         case .decimal(let d):
             self = .decimal(d)

Sources/RawStructuredFieldValues/Docs.docc/index.md

@@ -8,19 +8,19 @@ Provides parsing and serialization facilities for structured header field values
 
 ### About Structured Header Field Values
 
-HTTP Structured Header Field Values are a HTTP extension recorded in [RFC 8941](https://www.rfc-editor.org/rfc/rfc8941.html). They provide a set of data types and algorithms for handling HTTP header field values in a consistent way, allowing a single parser and serializer to handle a wide range of header field values.
+HTTP Structured Header Field Values are a HTTP extension recorded in [RFC 9651](https://www.ietf.org/rfc/rfc9651.html). They provide a set of data types and algorithms for handling HTTP header field values in a consistent way, allowing a single parser and serializer to handle a wide range of header field values.
 
 ### Swift HTTP Structured Header Field Values
 
-This package provides a parser and serializer that implement RFC 8941. They are entirely complete, able to handle all valid HTTP structured header field values.
+This package provides a parser and serializer that implement RFC 9651. They are entirely complete, able to handle all valid HTTP structured header field values.
 
 This package provides two top-level modules: `StructuredFieldValues` and `RawStructuredFieldValues`.
 
 This module, `RawStructuredFieldValues`, provides a low-level implementation of a serializer and parser. Both of these have been written to avoid using Foundation, making them suitable for a range of use-cases where Foundation is not available. They rely entirely on the Swift standard library and are implemented as generically as possible. One of the limitations due to the absence of Foundation is that this interface is not capable of performing Base64 encoding or decoding: users are free to bring whatever encoder and decoder they choose to use.
 
 This API is low-level, exposing the raw parse tree as the format for the serializer and parser. This allows high-performance and high-flexibility parsing and serialization, at the cost of being verbose and complex. Users are required to understand the structured header format and to operate the slightly awkward types, but maximal fidelity is retained and the performance overhead is low.
 
-The upper-level module, `StructuredFieldValues`, brings along the `Encoder` and `Decoder` and also adds a dependency on Foundation. This Foundation dependency is necessary to correctly handle the base64 formatting, as well as to provide a good natural container for binary data: `Data`. This interface is substantially friendlier and easier to work with, using Swift's `Codable` support to provide a great user experience.
+The upper-level module, `StructuredFieldValues`, brings along the `Encoder` and `Decoder` and also adds a dependency on Foundation. This Foundation dependency is necessary to correctly handle the base64 formatting, as well as to provide a good natural container for binary data: `Data`, and for dates: `Date`. This interface is substantially friendlier and easier to work with, using Swift's `Codable` support to provide a great user experience.
 
 In most cases users should prefer to use `StructuredFieldValues` unless they know they need the performance advantages of `RawStructuredFieldValues`. The experience will be much better.
 

Sources/RawStructuredFieldValues/FieldParser.swift

@@ -232,7 +232,7 @@ extension StructuredFieldValueParser {
     }
 
     private mutating func _parseAnIntegerOrDecimal(isDate: Bool) throws -> RFC9651BareItem {
-        var sign = 1
+        var sign = Int64(1)
         var type = IntegerOrDecimal.integer
 
         if let first = self.underlyingData.first, first == asciiDash {
@@ -304,7 +304,7 @@ extension StructuredFieldValueParser {
         case .integer:
             // This intermediate string is sad, we should rewrite this manually to avoid it.
             // This force-unwrap is safe, as we have validated that all characters are ascii digits.
-            let baseInt = Int(String(decoding: integerBytes, as: UTF8.self), radix: 10)!
+            let baseInt = Int64(String(decoding: integerBytes, as: UTF8.self), radix: 10)!
             let resultingInt = baseInt * sign
 
             if isDate {

Sources/StructuredFieldValues/Docs.docc/index.md

@@ -8,15 +8,15 @@ Provides parsing and serialization facilities for structured header field values
 
 ### About Structured Header Field Values
 
-HTTP Structured Header Field Values are a HTTP extension recorded in [RFC 8941](https://www.rfc-editor.org/rfc/rfc8941.html). They provide a set of data types and algorithms for handling HTTP header field values in a consistent way, allowing a single parser and serializer to handle a wide range of header field values.
+HTTP Structured Header Field Values are a HTTP extension recorded in [RFC 9651](https://www.ietf.org/rfc/rfc9651.html). They provide a set of data types and algorithms for handling HTTP header field values in a consistent way, allowing a single parser and serializer to handle a wide range of header field values.
 
 ### Swift HTTP Structured Header Field Values
 
-This package provides a parser and serializer that implement RFC 8941. They are entirely complete, able to handle all valid HTTP structured header field values. This package also provides `Encoder` and `Decoder` objects for working with Codable in Swift. This allows rapid prototyping and experimentation with HTTP structured header field values, as well as interaction with the wider Swift Codable community.
+This package provides a parser and serializer that implement RFC 9651. They are entirely complete, able to handle all valid HTTP structured header field values. This package also provides `Encoder` and `Decoder` objects for working with Codable in Swift. This allows rapid prototyping and experimentation with HTTP structured header field values, as well as interaction with the wider Swift Codable community.
 
 This package provides two top-level modules: `StructuredFieldValues` and `RawStructuredFieldValues`.
 
-This module, `StructuredFieldValues`, use the related module `RawStructuredFieldValues` to implement `Encoder` and `Decoder`. This interface is friendly and easy to work with.
+This module, `StructuredFieldValues`, uses the related module `RawStructuredFieldValues` to implement `Encoder` and `Decoder`. This interface is friendly and easy to work with.
 
 Users who have performance problems with this solution or have specific representational needs should investigate `RawStructuredFieldValues`.
 
@@ -56,12 +56,12 @@ let encoder = StructuredFieldValueEncoder()
 let serialized = try encoder.encode(AcceptCH(items: ["Sec-CH-Example", "Sec-CH-Example-2"]))
 ```
 
-However, structured header field values can be substantially more complex. Structured header fields can make use of 4 containers and 6 base item types. The containers are:
+However, structured header field values can be substantially more complex. Structured header fields can make use of 4 containers and 8 base item types. The containers are:
 
 1. Dictionaries. These are top-level elements and associate token keys with values. The values may be items, or may be inner lists, and each value may also have parameters associated with them. `StructuredFieldValues` can model dictionaries as either Swift objects (where the property names are dictionary keys).
 2. Lists. These are top-level elements, providing a sequence of items or inner lists. Each item or inner list may have parameters associated with them. `StructuredFieldValues` models these as Swift objects with one key, `items`, that must be a collection of entries.
 3. Inner Lists. These are lists that may be sub-entries of a dictionary or a list. The list entries are items, which may have parameters associated with them: additionally, an inner list may have parameters associated with itself as well. `StructuredFieldValues` models these as either Swift `Array`s _or_, if it's important to extract parameters, as a two-field Swift `struct` where one field is called `items` and contains an `Array`, and other field is called `parameters` and contains a dictionary.
-4. Parameters. Parameters associated token keys with items without parameters. These are used to store metadata about objects within a field. `StructuredFieldValues` models these as either Swift objects (where the property names are the parameter keys) or as Swift dictionaries.
+4. Parameters. Parameters associate token keys with items without parameters. These are used to store metadata about objects within a field. `StructuredFieldValues` models these as either Swift objects (where the property names are the parameter keys) or as Swift dictionaries.
 
 The base types are:
 
@@ -71,6 +71,8 @@ The base types are:
 4. Tokens. `StructuredFieldValues` models these as Swift's `String` type, where the range of characters is restricted.
 5. Strings. `StructuredFieldValues` models these as Swift's `String` type.
 6. Binary data. `StructuredFieldValues` models this as Foundation's `Data` type.
+7. Dates. `StructuredFieldValues` models these as Foundation's `Date` type.
+8. Display strings. `StructuredFieldValues` models these as the `DisplayString` type which it provides.
 
 For any Structured Header Field Value Item, the item may either be represented directly by the appropriate type, or by a Swift struct with two properties: `item` and `parameters`. This latter mode is how parameters on a given item may be captured.
 
@@ -83,6 +85,10 @@ The top-level Structured Header Field Value must identify what kind of header fi
 - ``StructuredFieldValue``
 - ``StructuredFieldType``
 
+### Helper Types
+
+- ``DisplayString``
+
 ### Encoding and Decoding
 
 - ``StructuredFieldValueEncoder``

Sources/StructuredFieldValues/Encoder/StructuredFieldValueEncoder.swift

@@ -313,7 +313,7 @@ extension _StructuredFieldEncoder: SingleValueEncodingContainer {
     }
 
     func encode(_ data: Date) throws {
-        let date = Int(data.timeIntervalSince1970)
+        let date = Int64(data.timeIntervalSince1970)
         try self.currentStackEntry.storage.insertBareItem(.date(date))
     }
 
@@ -371,7 +371,7 @@ extension _StructuredFieldEncoder: SingleValueEncodingContainer {
     }
 
     private func _encodeFixedWidthInteger<T: FixedWidthInteger>(_ value: T) throws {
-        guard let base = Int(exactly: value) else {
+        guard let base = Int64(exactly: value) else {
             throw StructuredHeaderError.integerOutOfRange
         }
         try self.currentStackEntry.storage.insertBareItem(.integer(base))
@@ -483,7 +483,7 @@ extension _StructuredFieldEncoder {
     }
 
     func append(_ value: Date) throws {
-        let date = Int(value.timeIntervalSince1970)
+        let date = Int64(value.timeIntervalSince1970)
         try self.currentStackEntry.storage.appendBareItem(.date(date))
     }
 
@@ -562,7 +562,7 @@ extension _StructuredFieldEncoder {
     }
 
     private func _appendFixedWidthInteger<T: FixedWidthInteger>(_ value: T) throws {
-        guard let base = Int(exactly: value) else {
+        guard let base = Int64(exactly: value) else {
             throw StructuredHeaderError.integerOutOfRange
         }
         try self.currentStackEntry.storage.appendBareItem(.integer(base))
@@ -667,7 +667,7 @@ extension _StructuredFieldEncoder {
 
     func encode(_ value: Date, forKey key: String) throws {
         let key = self.sanitizeKey(key)
-        let date = Int(value.timeIntervalSince1970)
+        let date = Int64(value.timeIntervalSince1970)
         try self.currentStackEntry.storage.insertBareItem(.date(date), atKey: key)
     }
 
@@ -789,7 +789,7 @@ extension _StructuredFieldEncoder {
     }
 
     private func _encodeFixedWidthInteger<T: FixedWidthInteger>(_ value: T, forKey key: String) throws {
-        guard let base = Int(exactly: value) else {
+        guard let base = Int64(exactly: value) else {
             throw StructuredHeaderError.integerOutOfRange
         }
         try self.currentStackEntry.storage.insertBareItem(.integer(base), atKey: key)