Make asyncMap to prevent from race-condition

Sources/ProjectSpec/Decoding.swift

@@ -12,16 +12,14 @@ extension Dictionary where Key: JSONKey {
             let defaultError = NSError(domain: "Unspecified error", code: 0, userInfo: nil)
             let keys = Array(dictionary.keys)
             var itemResults: [Result<T, Error>] = Array(repeating: .failure(defaultError), count: keys.count)
-            itemResults.withUnsafeMutableBufferPointer { buffer in
-                DispatchQueue.concurrentPerform(iterations: dictionary.count) { idx in
-                    do {
-                        let key = keys[idx]
-                        let jsonDictionary: JSONDictionary = try dictionary.json(atKeyPath: .key(key))
-                        let item = try T(name: key, jsonDictionary: jsonDictionary)
-                        buffer[idx] = .success(item)
-                    } catch {
-                        buffer[idx] = .failure(error)
-                    }
+            DispatchQueue.concurrentPerform(iterations: dictionary.count) { idx in
+                do {
+                    let key = keys[idx]
+                    let jsonDictionary: JSONDictionary = try dictionary.json(atKeyPath: .key(key))
+                    let item = try T(name: key, jsonDictionary: jsonDictionary)
+                    itemResults[idx] = .success(item)
+                } catch {
+                    itemResults[idx] = .failure(error)
                 }
             }
             return try itemResults.map { try $0.get() }

Sources/XcodeGenCore/ArrayExtensions.swift

@@ -1,15 +1,13 @@
 import Foundation
 
-public extension Array {
+public extension Array where Element: Sendable {
 
-   func parallelMap<T>(transform: (Element) -> T) -> [T] {
-       var result = ContiguousArray<T?>(repeating: nil, count: count)
-       return result.withUnsafeMutableBufferPointer { buffer in
-           DispatchQueue.concurrentPerform(iterations: buffer.count) { idx in
-               buffer[idx] = transform(self[idx])
-           }
-           return buffer.map { $0! }
-       }
+    func parallelMap<T>(transform: @Sendable (Element) -> T) -> [T] {
+      var buffer = ContiguousArray<T?>(repeating: nil, count: count)
+      DispatchQueue.concurrentPerform(iterations: count) { idx in
+        buffer[idx] = transform(self[idx])
+      }
+      return buffer.map { $0! }
    }
 }
 

Sources/XcodeGenCore/Glob.swift

@@ -89,12 +89,13 @@ public class Glob: Collection {
         }
 
         let patterns = behavior.supportsGlobstar ? expandGlobstar(pattern: adjustedPattern) : [adjustedPattern]
-
+
+        let isIncludingFiles = includeFiles
         #if os(macOS)
-        paths = patterns.parallelMap { paths(usingPattern: $0, includeFiles: includeFiles) }.flatMap { $0 }
+        paths = patterns.parallelMap { paths(usingPattern: $0, includeFiles: isIncludingFiles) }.flatMap { $0 }
         #else
         // Parallel invocations of Glob on Linux seems to be causing unexpected crashes
-        paths = patterns.map { paths(usingPattern: $0, includeFiles: includeFiles) }.flatMap { $0 }
+        paths = patterns.map { paths(usingPattern: $0, includeFiles: isIncludingFiles) }.flatMap { $0 }
         #endif
 
         paths = Array(Set(paths)).sorted { lhs, rhs in