Merge pull request #450 from lynchsft/swift_6_language_mode

Swift 6 language mode

Author: lynchsft

CHANGELOG.md

@@ -1,5 +1,28 @@
 ## Main
 
+## 6.0.0
+
+##### Breaking
+
+* YamlError.duplicatedKeysInMapping changed the types of its associated values
+  to conform to Sendable.
+  [Adora Lynch](https://github.com/lynchsft)
+
+##### Enhancements
+
+* Yams conforms to Swift 6 language mode with full concurrency checking
+  [Adora Lynch](https://github.com/lynchsft)
+
+##### Bug Fixes
+
+* None.
+
+## 5.3.1
+
+##### Breaking
+
+* None.
+
 ## 5.4.0
 
 ##### Breaking

Package@swift-6.swift

@@ -0,0 +1,31 @@
+// swift-tools-version:6.0
+import PackageDescription
+
+let package = Package(
+    name: "Yams",
+    products: [
+        .library(name: "Yams", targets: ["Yams"])
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "CYaml",
+            exclude: ["CMakeLists.txt"],
+            cSettings: [.define("YAML_DECLARE_STATIC")]
+        ),
+        .target(
+            name: "Yams",
+            dependencies: ["CYaml"],
+            exclude: ["CMakeLists.txt"],
+            cSettings: [.define("YAML_DECLARE_STATIC")]
+        ),
+        .testTarget(
+            name: "YamsTests",
+            dependencies: ["Yams"],
+            exclude: ["CMakeLists.txt"],
+            resources: [
+                .copy("Fixtures/SourceKitten#289/debug.yaml"),
+            ]
+        )
+    ]
+)

Sources/Yams/Constructor.swift

@@ -68,10 +68,10 @@ public final class Constructor {
 
 extension Constructor {
     /// The default `Constructor` to be used with APIs where none is explicitly provided.
-    public static let `default` = Constructor()
+    public static var `default`: Constructor { .init() }
 
     /// The default `Tag.Name` to `Node.Scalar` map.
-    public static let defaultScalarMap: ScalarMap = [
+    public static var defaultScalarMap: ScalarMap { [
         // Failsafe Schema
         .str: String.construct,
         // JSON Schema
@@ -82,24 +82,24 @@ extension Constructor {
         // http://yaml.org/type/index.html
         .binary: Data.construct,
         .timestamp: Date.construct
-    ]
+    ] }
 
     /// The default `Tag.Name` to `Node.Mapping` map.
-    public static let defaultMappingMap: MappingMap = [
+    public static var defaultMappingMap: MappingMap { [
         .map: [AnyHashable: Any].construct_mapping,
         // http://yaml.org/type/index.html
         .set: Set<AnyHashable>.construct_set
         // .merge is supported in `[AnyHashable: Any].construct_mapping`.
         // .value is supported in `String.construct` and `[AnyHashable: Any].construct_mapping`.
-    ]
+    ] }
 
     /// The default `Tag.Name` to `Node.Sequence` map.
-    public static let defaultSequenceMap: SequenceMap = [
+    public static var defaultSequenceMap: SequenceMap { [
         .seq: [Any].construct_seq,
         // http://yaml.org/type/index.html
         .omap: [Any].construct_omap,
         .pairs: [Any].construct_pairs
-    ]
+    ] }
 }
 
 // MARK: - ScalarConstructible

Sources/Yams/Encoder.swift

@@ -344,12 +344,12 @@ struct _YAMLCodingKey: CodingKey { // swiftlint:disable:this type_name
 // MARK: -
 
 private extension Node {
-    static let null = Node("null", Tag(.null))
-    static let unused = Node("", .unused)
+    static var null: Node { Node("null", Tag(.null)) }
+    static var unused: Node { Node("", .unused) }
 }
 
 private extension Tag {
-    static let unused = Tag(.unused)
+    static var unused: Tag { Tag(.unused) }
 }
 
 private extension Tag.Name {

Sources/Yams/Mark.swift

@@ -7,7 +7,7 @@
 //
 
 /// The pointer position.
-public struct Mark {
+public struct Mark: Sendable {
     /// Line number starting from 1.
     public let line: Int
     /// Column number starting from 1. libYAML counts columns in `UnicodeScalar`.

Sources/Yams/Parser.swift

@@ -132,7 +132,7 @@ public final class Parser {
         /// The default encoding, determined at run time based on the String type's native encoding.
         /// This can be overridden by setting `YAMS_DEFAULT_ENCODING` to either `UTF8` or `UTF16`.
         /// This value is case insensitive.
-        public static var `default`: Encoding = {
+        public static var `default`: Encoding {
             let key = "YAMS_DEFAULT_ENCODING"
             if let yamsEncoding = ProcessInfo.processInfo.environment[key],
                 let encoding = Encoding(rawValue: yamsEncoding.lowercased()) {
@@ -142,7 +142,7 @@ public final class Parser {
                 return encoding
             }
             return key.utf8.withContiguousStorageIfAvailable({ _ in true }) != nil ? .utf8 : .utf16
-        }()
+        }
 
         /// The equivalent `Swift.Encoding` value for `self`.
         public var swiftStringEncoding: String.Encoding {
@@ -397,7 +397,13 @@ private extension Parser {
     private func checkDuplicates(mappingKeys: [Node]) throws {
         let duplicates: [Node: [Node]] = Dictionary(grouping: mappingKeys) { $0 }.filter { $1.count > 1 }
         guard duplicates.isEmpty else {
-            throw YamlError.duplicatedKeysInMapping(duplicates: duplicates, yaml: yaml)
+            let sortedKeys = duplicates.keys.sorted()
+            let firstKey = sortedKeys.first!
+            let firstMark = firstKey.mark ?? .init(line: 0, column: 0)
+            let duplicates = sortedKeys.map { $0.string ?? "<uncovertable>" }
+            throw YamlError.duplicatedKeysInMapping(duplicates: duplicates,
+                                                    context: .init(text: yaml,
+                                                                   mark: firstMark))
         }
     }
 

Sources/Yams/Resolver.swift

@@ -9,9 +9,9 @@
 import Foundation
 
 /// Class used to resolve nodes to tags based on customizable rules.
-public final class Resolver {
+public final class Resolver: Sendable {
     /// Rule describing how to resolve tags from regex patterns.
-    public struct Rule {
+    public struct Rule: Sendable {
         /// The tag name this rule applies to.
         public let tag: Tag.Name
         fileprivate let regexp: NSRegularExpression

Sources/Yams/Tag.swift

@@ -9,7 +9,7 @@
 /// Tags describe the the _type_ of a Node.
 public final class Tag {
     /// Tag name.
-    public struct Name: RawRepresentable, Hashable {
+    public struct Name: RawRepresentable, Hashable, Sendable {
         /// This `Tag.Name`'s raw string value.
         public let rawValue: String
         /// Create a `Tag.Name` with a raw string value.

Sources/Yams/YamlAnchorProviding.swift

@@ -22,24 +22,5 @@ public protocol YamlAnchorCoding: YamlAnchorProviding {
 }
 
 internal extension Node {
-    static let anchorKeyNode: Self = .scalar(.init(YamlAnchorFunctionNameProvider().getName()))
-}
-
-private final class YamlAnchorFunctionNameProvider: YamlAnchorProviding {
-
-    fileprivate var functionName: StaticString?
-
-    var yamlAnchor: Anchor? {
-        functionName = #function
-        return nil
-    }
-
-    func getName() -> StaticString {
-        _ = yamlAnchor
-        return functionName!
-    }
-
-    func getName() -> String {
-        String(describing: getName() as StaticString)
-    }
+    static var anchorKeyNode: Self { .scalar(.init("yamlAnchor")) }
 }

Sources/Yams/YamlError.swift

@@ -85,10 +85,10 @@ public enum YamlError: Error {
     ///
     /// - parameter duplicates: A dictionary keyed by the duplicated node value, with all nodes that duplicate the value
     /// - parameter yaml:       YAML String which the problem occured while reading. 
-    case duplicatedKeysInMapping(duplicates: [Node: [Node]], yaml: String)
+    case duplicatedKeysInMapping(duplicates: [String], context: Context)
 
     /// The error context.
-    public struct Context: CustomStringConvertible {
+    public struct Context: CustomStringConvertible, Sendable {
         /// Context text.
         public let text: String
         /// Context position.
@@ -187,20 +187,14 @@ extension YamlError: CustomStringConvertible {
             return problem
         case .dataCouldNotBeDecoded(encoding: let encoding):
             return "String could not be decoded from data using '\(encoding)' encoding"
-        case let .duplicatedKeysInMapping(duplicates, yaml):
-            return duplicates.duplicatedKeyErrorDescription(yaml: yaml)
-        }
-    }
-}
+        case let .duplicatedKeysInMapping(duplicates, context):
+            let duplicateKeys = duplicates.sorted().map { "'\($0)'" }.joined(separator: ", ")
+            return """
+                   Parser: expected all keys to be unique but found the following duplicated key(s): \(duplicateKeys).
+                   Context:
+                   \(context.description)
+                   """
 
-private extension Dictionary where Key == Node, Value == [Node] {
-    func duplicatedKeyErrorDescription(yaml: String) -> String {
-        var error = "error: parser: expected all keys to be unique but found the following duplicated key(s):"
-        for key in self.keys.sorted() {
-            let duplicatedNodes = self[key]!
-            let marks = duplicatedNodes.compactMap { $0.mark }
-            error += "\n\(key.any) (\(marks)):\n\(marks.map { $0.snippet(from: yaml) }.joined(separator: "\n"))"
         }
-        return error
     }
 }