Swift 6.2 as minimum toolchain version

Author: czechboy0

.spi.yml

@@ -1,7 +1,7 @@
 version: 1
 builder:
   configs:
-    - swift_version: '6.1'
+    - swift_version: '6.2'
       documentation_targets:
         - Configuration
         - ConfigurationTesting

Examples/hello-world-cli-example/Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 6.1
+// swift-tools-version: 6.2
 
 import PackageDescription
 

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 6.1
+// swift-tools-version: 6.2
 
 import PackageDescription
 #if canImport(FoundationEssentials)
@@ -61,6 +61,7 @@ let enableAllTraitsExplicit = ProcessInfo.processInfo.environment["ENABLE_ALL_TR
 
 let enableAllTraits = spiGenerateDocs || previewDocs || enableAllTraitsExplicit
 let addDoccPlugin = previewDocs || spiGenerateDocs
+let enableAllCIFlags = enableAllTraitsExplicit
 
 traits.insert(
     .default(
@@ -77,6 +78,7 @@ let package = Package(
     traits: traits,
     dependencies: [
         .package(url: "https://github.com/apple/swift-system", from: "1.5.0"),
+        .package(url: "https://github.com/apple/swift-collections", from: "1.3.0"),
         .package(url: "https://github.com/swift-server/swift-service-lifecycle", from: "2.7.0"),
         .package(url: "https://github.com/apple/swift-log", from: "1.6.3"),
         .package(url: "https://github.com/apple/swift-metrics", from: "2.7.0"),
@@ -92,6 +94,10 @@ let package = Package(
                     name: "SystemPackage",
                     package: "swift-system"
                 ),
+                .product(
+                    name: "DequeModule",
+                    package: "swift-collections"
+                ),
                 .product(
                     name: "Logging",
                     package: "swift-log",
@@ -179,8 +185,16 @@ for target in package.targets {
     // https://github.com/swiftlang/swift-evolution/blob/main/proposals/0409-access-level-on-imports.md
     settings.append(.enableUpcomingFeature("InternalImportsByDefault"))
 
+    // https://docs.swift.org/compiler/documentation/diagnostics/nonisolated-nonsending-by-default/
+    settings.append(.enableUpcomingFeature("NonisolatedNonsendingByDefault"))
+
     settings.append(.enableExperimentalFeature("AvailabilityMacro=Configuration 1.0:macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0"))
 
+    if enableAllCIFlags {
+        // Ensure all public types are explicitly annotated as Sendable or not Sendable.
+        settings.append(.unsafeFlags(["-Xfrontend", "-require-explicit-sendable"]))
+    }
+
     target.swiftSettings = settings
 }
 

Sources/Configuration/MultiProvider.swift

@@ -199,24 +199,27 @@ extension MultiProvider {
         _ body: (ConfigUpdatesAsyncSequence<MultiSnapshot, Never>) async throws -> Return
     ) async throws -> Return {
         let providers = storage.providers
-        let sources:
-            [@Sendable (
-                (ConfigUpdatesAsyncSequence<any ConfigSnapshotProtocol, Never>) async throws -> Void
-            ) async throws -> Void] = providers.map { $0.watchSnapshot }
-        return try await combineLatestOneOrMore(
-            elementType: (any ConfigSnapshotProtocol).self,
-            sources: sources,
-            updatesHandler: { updateArrays in
-                try await body(
-                    ConfigUpdatesAsyncSequence(
-                        updateArrays
-                            .map { array in
-                                MultiSnapshot(snapshots: array)
-                            }
-                    )
+        typealias UpdatesSequence = any (AsyncSequence<any ConfigSnapshotProtocol, Never> & Sendable)
+        var updateSequences: [UpdatesSequence] = []
+        updateSequences.reserveCapacity(providers.count)
+        return try await withProvidersWatchingSnapshot(
+            providers: ArraySlice(providers),
+            updateSequences: &updateSequences,
+        ) { providerUpdateSequences in
+            let updateArrays = combineLatestMany(
+                elementType: (any ConfigSnapshotProtocol).self,
+                failureType: Never.self,
+                providerUpdateSequences
+            )
+            return try await body(
+                ConfigUpdatesAsyncSequence(
+                    updateArrays
+                        .map { array in
+                            MultiSnapshot(snapshots: array)
+                        }
                 )
-            }
-        )
+            )
+        }
     }
 
     /// Asynchronously resolves a configuration value from nested providers.
@@ -290,43 +293,86 @@ extension MultiProvider {
     ) async throws -> Return {
         let providers = storage.providers
         let providerNames = providers.map(\.providerName)
-        let sources:
-            [@Sendable (
-                (
-                    ConfigUpdatesAsyncSequence<Result<LookupResult, any Error>, Never>
-                ) async throws -> Void
-            ) async throws -> Void] = providers.map { provider in
-                { handler in
-                    _ = try await provider.watchValue(forKey: key, type: type, updatesHandler: handler)
-                }
-            }
-        return try await combineLatestOneOrMore(
-            elementType: Result<LookupResult, any Error>.self,
-            sources: sources,
-            updatesHandler: { updateArrays in
-                try await updatesHandler(
-                    ConfigUpdatesAsyncSequence(
-                        updateArrays
-                            .map { array in
-                                var results: [AccessEvent.ProviderResult] = []
-                                for (providerIndex, lookupResult) in array.enumerated() {
-                                    let providerName = providerNames[providerIndex]
-                                    results.append(.init(providerName: providerName, result: lookupResult))
-                                    switch lookupResult {
-                                    case .success(let value) where value.value == nil:
-                                        // Got a success + nil from a nested provider, keep iterating.
-                                        continue
-                                    default:
-                                        // Got a success + non-nil or an error from a nested provider, propagate that up.
-                                        return (results, lookupResult.map { $0.value })
-                                    }
+        typealias UpdatesSequence = any (AsyncSequence<Result<LookupResult, any Error>, Never> & Sendable)
+        var updateSequences: [UpdatesSequence] = []
+        updateSequences.reserveCapacity(providers.count)
+        return try await withProvidersWatchingValue(
+            providers: ArraySlice(providers),
+            updateSequences: &updateSequences,
+            key: key,
+            configType: type,
+        ) { providerUpdateSequences in
+            let updateArrays = combineLatestMany(
+                elementType: Result<LookupResult, any Error>.self,
+                failureType: Never.self,
+                providerUpdateSequences
+            )
+            return try await updatesHandler(
+                ConfigUpdatesAsyncSequence(
+                    updateArrays
+                        .map { array in
+                            var results: [AccessEvent.ProviderResult] = []
+                            for (providerIndex, lookupResult) in array.enumerated() {
+                                let providerName = providerNames[providerIndex]
+                                results.append(.init(providerName: providerName, result: lookupResult))
+                                switch lookupResult {
+                                case .success(let value) where value.value == nil:
+                                    // Got a success + nil from a nested provider, keep iterating.
+                                    continue
+                                default:
+                                    // Got a success + non-nil or an error from a nested provider, propagate that up.
+                                    return (results, lookupResult.map { $0.value })
                                 }
-                                // If all nested results were success + nil, return the same.
-                                return (results, .success(nil))
                             }
-                    )
+                            // If all nested results were success + nil, return the same.
+                            return (results, .success(nil))
+                        }
                 )
-            }
+            )
+        }
+    }
+}
+
+@available(Configuration 1.0, *)
+nonisolated(nonsending) private func withProvidersWatchingValue<ReturnInner>(
+    providers: ArraySlice<any ConfigProvider>,
+    updateSequences: inout [any (AsyncSequence<Result<LookupResult, any Error>, Never> & Sendable)],
+    key: AbsoluteConfigKey,
+    configType: ConfigType,
+    body: ([any (AsyncSequence<Result<LookupResult, any Error>, Never> & Sendable)]) async throws -> ReturnInner
+) async throws -> ReturnInner {
+    guard let provider = providers.first else {
+        // Recursion termination, once we've collected all update sequences, execute the body.
+        return try await body(updateSequences)
+    }
+    return try await provider.watchValue(forKey: key, type: configType) { updates in
+        updateSequences.append(updates)
+        return try await withProvidersWatchingValue(
+            providers: providers.dropFirst(),
+            updateSequences: &updateSequences,
+            key: key,
+            configType: configType,
+            body: body
+        )
+    }
+}
+
+@available(Configuration 1.0, *)
+nonisolated(nonsending) private func withProvidersWatchingSnapshot<ReturnInner>(
+    providers: ArraySlice<any ConfigProvider>,
+    updateSequences: inout [any (AsyncSequence<any ConfigSnapshotProtocol, Never> & Sendable)],
+    body: ([any (AsyncSequence<any ConfigSnapshotProtocol, Never> & Sendable)]) async throws -> ReturnInner
+) async throws -> ReturnInner {
+    guard let provider = providers.first else {
+        // Recursion termination, once we've collected all update sequences, execute the body.
+        return try await body(updateSequences)
+    }
+    return try await provider.watchSnapshot { updates in
+        updateSequences.append(updates)
+        return try await withProvidersWatchingSnapshot(
+            providers: providers.dropFirst(),
+            updateSequences: &updateSequences,
+            body: body
         )
     }
 }

Sources/Configuration/Utilities/AsyncAlgos/AsyncCombineLatestManySequence.swift

@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftConfiguration open source project
+//
+// Copyright (c) 2025 Apple Inc. and the SwiftConfiguration project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftConfiguration project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Async Algorithms open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+// Vendored copy of https://github.com/apple/swift-async-algorithms/pull/360
+
+/// Creates an asynchronous sequence that combines the latest values from many `AsyncSequence` types
+/// by emitting a tuple of the values. ``combineLatestMany(_:)`` only emits a value whenever any of the base `AsyncSequence`s
+/// emit a value (so long as each of the bases have emitted at least one value).
+///
+/// Finishes:
+/// ``combineLatestMany(_:)`` finishes when one of the bases finishes before emitting any value or
+/// when all bases finished.
+///
+/// Throws:
+/// ``combineLatestMany(_:)`` throws when one of the bases throws. If one of the bases threw any buffered and not yet consumed
+/// values will be dropped.
+@available(Configuration 1.0, *)
+internal func combineLatestMany<Element: Sendable, Failure: Error>(
+    elementType: Element.Type = Element.self,
+    failureType: Failure.Type = Failure.self,
+    _ bases: [any (AsyncSequence<Element, Failure> & Sendable)]
+) -> some AsyncSequence<[Element], Failure> & Sendable {
+    AsyncCombineLatestManySequence<Element, Failure>(bases)
+}
+
+/// An `AsyncSequence` that combines the latest values produced from many asynchronous sequences into an asynchronous sequence of tuples.
+@available(Configuration 1.0, *)
+internal struct AsyncCombineLatestManySequence<Element: Sendable, Failure: Error>: AsyncSequence, Sendable {
+    // swift-format-ignore: AllPublicDeclarationsHaveDocumentation
+    public typealias AsyncIterator = Iterator
+
+    typealias Base = AsyncSequence<Element, Failure> & Sendable
+    let bases: [any Base]
+
+    init(_ bases: [any Base]) {
+        self.bases = bases
+    }
+
+    // swift-format-ignore: AllPublicDeclarationsHaveDocumentation
+    public func makeAsyncIterator() -> AsyncIterator {
+        Iterator(
+            storage: .init(self.bases)
+        )
+    }
+
+    // swift-format-ignore: AllPublicDeclarationsHaveDocumentation
+    public struct Iterator: AsyncIteratorProtocol {
+        final class InternalClass {
+            private let storage: CombineLatestManyStorage<Element, Failure>
+
+            fileprivate init(storage: CombineLatestManyStorage<Element, Failure>) {
+                self.storage = storage
+            }
+
+            deinit {
+                self.storage.iteratorDeinitialized()
+            }
+
+            func next() async throws(Failure) -> [Element]? {
+                guard let element = try await self.storage.next() else {
+                    return nil
+                }
+
+                // This force unwrap is safe since there must be a third element.
+                return element
+            }
+        }
+
+        let internalClass: InternalClass
+
+        fileprivate init(storage: CombineLatestManyStorage<Element, Failure>) {
+            self.internalClass = InternalClass(storage: storage)
+        }
+
+        public mutating func next() async throws(Failure) -> [Element]? {
+            try await self.internalClass.next()
+        }
+    }
+}
+
+@available(*, unavailable)
+extension AsyncCombineLatestManySequence.Iterator: Sendable {}