Update project to Swift 5.10 and start on Sendable updates

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.8
+// swift-tools-version:5.10
 
 import PackageDescription
 

Sources/XcodeProj/Extensions/NSLocking+withLock.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+// reimplemention of `withLock` from `NSLocking` extension that is exclusive to the macOS version of `Foundation`
+extension NSLocking {
+  func withLock<T>(_ body: () throws -> T) rethrows -> T {
+    lock()
+    defer { unlock() }
+    return try body()
+  }
+}
+

Sources/XcodeProj/Objects/Configuration/BuildSettings.swift

@@ -1,4 +1,53 @@
 import Foundation
 
 /// Build settings.
-public typealias BuildSettings = [String: Any]
+public typealias BuildSettings = [String: BuildSetting]
+
+public enum BuildSetting: Sendable, Equatable {
+    case string(String)
+    case array([String])
+
+    var valueForWriting: String {
+        switch self {
+        case .string(let string):
+            return string
+        case .array(let array):
+            return array.joined(separator: " ")
+        }
+    }
+}
+
+extension BuildSetting: Codable {
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        do  {
+            let string = try container.decode(String.self)
+            self = .string(string)
+        } catch {
+            let array = try container.decode([String].self)
+            self = .array(array)
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case .string(let string):
+            try container.encode(string)
+        case .array(let array):
+            try container.encode(array)
+        }
+    }
+}
+
+extension BuildSetting: ExpressibleByArrayLiteral {
+    public init(arrayLiteral elements: String...) {
+        self = .array(elements)
+    }
+}
+
+extension BuildSetting: ExpressibleByStringLiteral {
+    public init(stringLiteral value: StringLiteralType) {
+        self = .string(value)
+    }
+}

Sources/XcodeProj/Objects/Configuration/XCBuildConfiguration.swift

@@ -43,26 +43,26 @@ public final class XCBuildConfiguration: PBXObject {
     }
 
     // MARK: - Decodable
-
-    fileprivate enum CodingKeys: String, CodingKey {
-        case baseConfigurationReference
-        case buildSettings
-        case name
-    }
-
-    public required init(from decoder: Decoder) throws {
-        let objects = decoder.context.objects
-        let objectReferenceRepository = decoder.context.objectReferenceRepository
-        let container = try decoder.container(keyedBy: CodingKeys.self)
-        if let baseConfigurationReference: String = try container.decodeIfPresent(.baseConfigurationReference) {
-            self.baseConfigurationReference = objectReferenceRepository.getOrCreate(reference: baseConfigurationReference, objects: objects)
-        } else {
-            baseConfigurationReference = nil
-        }
-        buildSettings = try container.decode([String: Any].self, forKey: .buildSettings)
-        name = try container.decode(.name)
-        try super.init(from: decoder)
+
+  fileprivate enum CodingKeys: String, CodingKey {
+    case baseConfigurationReference
+    case buildSettings
+    case name
+  }
+
+  public required init(from decoder: Decoder) throws {
+    let objects = decoder.context.objects
+    let objectReferenceRepository = decoder.context.objectReferenceRepository
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    if let baseConfigurationReference: String = try container.decodeIfPresent(.baseConfigurationReference) {
+      self.baseConfigurationReference = objectReferenceRepository.getOrCreate(reference: baseConfigurationReference, objects: objects)
+    } else {
+      baseConfigurationReference = nil
     }
+    buildSettings = try container.decode(BuildSettings.self, forKey: .buildSettings)
+    name = try container.decode(.name)
+    try super.init(from: decoder)
+  }
 
     // MARK: - Public
 
@@ -75,16 +75,16 @@ public final class XCBuildConfiguration: PBXObject {
     public func append(setting name: String, value: String) {
         guard !value.isEmpty else { return }
 
-        let existing: Any = buildSettings[name] ?? "$(inherited)"
+        let existing: BuildSetting = buildSettings[name] ?? "$(inherited)"
 
         switch existing {
-        case let string as String where string != value:
+        case let .string(string) where string != value:
             let newValue = [string, value].joined(separator: " ")
-            buildSettings[name] = newValue
-        case let array as [String]:
+            buildSettings[name] = .string(newValue)
+        case let .array(array):
             var newValue = array
             newValue.append(value)
-            buildSettings[name] = newValue.uniqued()
+            buildSettings[name] = .array(newValue.uniqued())
         default:
             break
         }

Sources/XcodeProj/Objects/Project/PBXObjectReference.swift

@@ -1,72 +1,102 @@
 import Foundation
 
 /// Object used as a reference to PBXObjects from PBXObjects.
-class PBXObjectReference: NSObject, Comparable, NSCopying {
+class PBXObjectReference: NSObject, Comparable, NSCopying, @unchecked Sendable {
+    private let lock = NSRecursiveLock()
+
     /// Boolean that indicates whether the id is temporary and needs
     /// to be regenerated when saving it to disk.
-    private(set) var temporary: Bool
+    var temporary: Bool {
+        lock.withLock { _temporary }
+    }
+    private var _temporary: Bool
 
     /// String reference.
-    private(set) var value: String
+    var value: String {
+        lock.withLock { _value }
+    }
+    private var _value: String
+
 
     /// Weak reference to the objects instance that contains the project objects.
-    weak var objects: PBXObjects?
+    var objects: PBXObjects? {
+        get {
+            lock.withLock { _objects }
+        }
+        set {
+            lock.withLock {
+                _objects = newValue
+            }
+        }
+    }
+    private weak var _objects: PBXObjects?
 
+    // QUESTION: this is exposed to the project but so is `getThrowingObject` and `getObject`.  What access patterns do we want to support?
     /// A weak reference to the object
-    private weak var object: PBXObject?
+    var object: PBXObject? {
+        get {
+            lock.withLock { _object }
+        }
+    }
+    private weak var _object: PBXObject?
 
     /// Initializes a non-temporary reference.
     ///
     /// - Parameter reference: reference.
     init(_ reference: String, objects: PBXObjects) {
-        value = reference
-        temporary = false
-        self.objects = objects
+        _value = reference
+        _temporary = false
+        _objects = objects
     }
 
     /// Initializes a temporary reference
     init(objects: PBXObjects? = nil) {
-        value = "TEMP_\(UUID().uuidString)"
-        temporary = true
-        self.objects = objects
+        _value = "TEMP_\(UUID().uuidString)"
+        _temporary = true
+        _objects = objects
     }
 
     /// Initializes the reference without objects.
     ///
     /// - Parameter reference: reference.
     init(_ reference: String) {
-        value = reference
-        temporary = false
+        _value = reference
+        _temporary = false
     }
 
     /// Initializes the object reference with another object reference, copying its values.
     ///
     /// - Parameter objectReference: object reference to be initialized from.
     required init(_ objectReference: PBXObjectReference) {
-        value = objectReference.value
-        temporary = objectReference.temporary
+        _value = objectReference.value
+        _temporary = objectReference.temporary
     }
 
     /// Fixes its value making it permanent.
     ///
     /// - Parameter value: value.
     func fix(_ value: String) {
-        let object = objects?.delete(reference: self)
-        self.value = value
-        temporary = false
-        if let object = object {
-            objects?.add(object: object)
+        lock.withLock {
+            let object = objects?.delete(reference: self)
+            _value = value
+            _temporary = false
+            if let object = object {
+                objects?.add(object: object)
+            }
         }
     }
 
     /// Invalidates the reference making it temporary.
     func invalidate() {
-        let object = objects?.delete(reference: self)
-        value = "TEMP_\(UUID().uuidString)"
-        temporary = true
-        if let object = object {
-            objects?.add(object: object)
+        lock.withLock {
+            let object = _objects?.delete(reference: self)
+            _value = "TEMP_\(UUID().uuidString)"
+            _temporary = true
+            if let object = object {
+                _objects?.add(object: object)
+            }
         }
+
     }
 
     /// Hash value.
@@ -112,7 +142,9 @@ class PBXObjectReference: NSObject, Comparable, NSCopying {
     ///
     /// - Parameter object: The object
     func setObject(_ object: PBXObject) {
-        self.object = object
+        lock.withLock {
+            _object = object
+        }
     }
 
     /// Returns the object the reference is referfing to.
@@ -130,14 +162,17 @@ class PBXObjectReference: NSObject, Comparable, NSCopying {
         if let object = object as? T {
             return object
         }
-        guard let objects = objects else {
-            throw PBXObjectError.objectsReleased
-        }
-        guard let object = objects.get(reference: self) as? T else {
-            throw PBXObjectError.objectNotFound(value)
+        return try lock.withLock {
+            guard let objects = objects else {
+                throw PBXObjectError.objectsReleased
+            }
+            guard let object = objects.get(reference: self) as? T else {
+                throw PBXObjectError.objectNotFound(value)
+            }
+            _object = object
+            return object
         }
-        self.object = object
-        return object
+
     }
 }