Updates to Swift-Log v1.4.4 and adds Sendable support throughout

Author: shaps80

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:5.5
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription

Sources/Logging/Interpolation.swift

@@ -1,19 +1,19 @@
 import CoreGraphics
 
-@frozen public struct LogInterpolation: StringInterpolationProtocol {
+@frozen public struct LogInterpolation: StringInterpolationProtocol, Sendable {
 
-    @usableFromInline enum Value {
+    @usableFromInline enum Value: Sendable {
         case literal(String)
-        case string(() -> String, alignment: LogStringAlignment, privacy: LogPrivacy)
-        case convertible(() -> CustomStringConvertible, alignment: LogStringAlignment, privacy: LogPrivacy)
-        case signedInt(() -> Int64, format: LogIntegerFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
-        case unsignedInt(() -> UInt64, format: LogIntegerFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
-        case float(() -> Float, format: LogFloatFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
-        case cgfloat(() -> CGFloat, format: LogFloatFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
-        case double(() -> Double, format: LogFloatFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
-        case bool(() -> Bool, format: LogBoolFormat, privacy: LogPrivacy)
-        case object(() -> NSObject, privacy: LogPrivacy)
-        case meta(() -> Any.Type, alignment: LogStringAlignment, privacy: LogPrivacy)
+        case string(@Sendable () -> String, alignment: LogStringAlignment, privacy: LogPrivacy)
+        case convertible(@Sendable () -> CustomStringConvertible, alignment: LogStringAlignment, privacy: LogPrivacy)
+        case signedInt(@Sendable () -> Int64, format: LogIntegerFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
+        case unsignedInt(@Sendable () -> UInt64, format: LogIntegerFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
+        case float(@Sendable () -> Float, format: LogFloatFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
+        case cgfloat(@Sendable () -> CGFloat, format: LogFloatFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
+        case double(@Sendable () -> Double, format: LogFloatFormatting, alignment: LogStringAlignment, privacy: LogPrivacy)
+        case bool(@Sendable () -> Bool, format: LogBoolFormat, privacy: LogPrivacy)
+        case object(@Sendable () -> NSObject, privacy: LogPrivacy)
+        case meta(@Sendable () -> Any.Type, alignment: LogStringAlignment, privacy: LogPrivacy)
     }
 
     private(set) var storage: [Value] = []
@@ -28,77 +28,77 @@ import CoreGraphics
 
 extension LogInterpolation {
     /// Defines interpolation for expressions of type String.
-    public mutating func appendInterpolation(_ argumentString: @autoclosure @escaping () -> String, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation(_ argumentString: @Sendable @autoclosure @escaping () -> String, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
         storage.append(.string(argumentString, alignment: align, privacy: privacy))
     }
 
     /// Defines interpolation for values conforming to CustomStringConvertible. The values
     /// are displayed using the description methods on them.
-    public mutating func appendInterpolation<T>(_ value: @autoclosure @escaping () -> T, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) where T: CustomStringConvertible {
+    public mutating func appendInterpolation<T>(_ value: @Sendable @autoclosure @escaping () -> T, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) where T: CustomStringConvertible {
         storage.append(.convertible(value, alignment: align, privacy: privacy))
     }
 }
 
 extension LogInterpolation {
     /// Defines interpolation for meta-types.
-    public mutating func appendInterpolation(_ value: @autoclosure @escaping () -> Any.Type, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation(_ value: @Sendable @autoclosure @escaping () -> Any.Type, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
         storage.append(.meta(value, alignment: align, privacy: privacy))
     }
 
     /// Defines interpolation for expressions of type NSObject.
-    public mutating func appendInterpolation(_ argumentObject: @autoclosure @escaping () -> NSObject, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation(_ argumentObject: @Sendable @autoclosure @escaping () -> NSObject, privacy: LogPrivacy = .private) {
         storage.append(.object(argumentObject, privacy: privacy))
     }
 }
 
 extension LogInterpolation {
     /// Defines interpolation for expressions of type Int
-    public mutating func appendInterpolation<T: SignedInteger>(_ number: @autoclosure @escaping () -> T, format: LogIntegerFormatting = .decimal, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation<T: SignedInteger>(_ number: @Sendable @autoclosure @escaping () -> T, format: LogIntegerFormatting = .decimal, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
         storage.append(.signedInt({ Int64(number()) }, format: format, alignment: align, privacy: privacy))
     }
 
     /// Defines interpolation for expressions of type UInt
-    public mutating func appendInterpolation<T: UnsignedInteger>(_ number: @autoclosure @escaping () -> T, format: LogIntegerFormatting = .decimal, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation<T: UnsignedInteger>(_ number: @Sendable @autoclosure @escaping () -> T, format: LogIntegerFormatting = .decimal, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
         storage.append(.unsignedInt({ UInt64(number()) }, format: format, alignment: align, privacy: privacy))
     }
 }
 
 extension LogInterpolation {
     /// Defines interpolation for expressions of type Float
-    public mutating func appendInterpolation(_ number: @autoclosure @escaping () -> Float, format: LogFloatFormatting = .fixed, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation(_ number: @Sendable @autoclosure @escaping () -> Float, format: LogFloatFormatting = .fixed, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
         storage.append(.float(number, format: format, alignment: align, privacy: privacy))
     }
 
     /// Defines interpolation for expressions of type CGFloat
-    public mutating func appendInterpolation(_ number: @autoclosure @escaping () -> CGFloat, format: LogFloatFormatting = .fixed, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation(_ number: @Sendable @autoclosure @escaping () -> CGFloat, format: LogFloatFormatting = .fixed, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
         storage.append(.cgfloat(number, format: format, alignment: align, privacy: privacy))
     }
 
     /// Defines interpolation for expressions of type Double
-    public mutating func appendInterpolation(_ number: @autoclosure @escaping () -> Double, format: LogFloatFormatting = .fixed, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation(_ number: @Sendable @autoclosure @escaping () -> Double, format: LogFloatFormatting = .fixed, align: LogStringAlignment = .none, privacy: LogPrivacy = .private) {
         storage.append(.double(number, format: format, alignment: align, privacy: privacy))
     }
 }
 
 extension LogInterpolation {
     /// Defines interpolation for expressions of type Bool
-    public mutating func appendInterpolation(_ boolean: @autoclosure @escaping () -> Bool, format: LogBoolFormat = .truth, privacy: LogPrivacy = .private) {
+    public mutating func appendInterpolation(_ boolean: @Sendable @autoclosure @escaping () -> Bool, format: LogBoolFormat = .truth, privacy: LogPrivacy = .private) {
         storage.append(.bool(boolean, format: format, privacy: privacy))
     }
 }
 
-public enum LogBoolFormat {
+public enum LogBoolFormat: Sendable {
     /// Displays an interpolated boolean value as true or false.
     case truth
     /// Displays an interpolated boolean value as yes or no.
     case answer
 }
 
-public struct LogStringAlignment {
-    enum Alignment {
+public struct LogStringAlignment: Sendable {
+    enum Alignment: Sendable {
         case none
-        case left(columns: () -> Int)
-        case right(columns: () -> Int)
+        case left(columns: @Sendable () -> Int)
+        case right(columns: @Sendable () -> Int)
     }
 
     let alignment: Alignment
@@ -107,18 +107,18 @@ public struct LogStringAlignment {
         LogStringAlignment(alignment: .none)
     }
 
-    public static func right(columns: @autoclosure @escaping () -> Int) -> LogStringAlignment {
+    public static func right(columns: @Sendable @autoclosure @escaping () -> Int) -> LogStringAlignment {
         LogStringAlignment(alignment: .right(columns: columns))
     }
 
-    public static func left(columns: @autoclosure @escaping () -> Int) -> LogStringAlignment {
+    public static func left(columns: @Sendable @autoclosure @escaping () -> Int) -> LogStringAlignment {
         LogStringAlignment(alignment: .left(columns: columns))
     }
 }
 
-public struct LogFloatFormatting {
-    enum Format {
-        case fixed(precision: () -> Int, explicitPositiveSign: Bool)
+public struct LogFloatFormatting: Sendable {
+    enum Format: Sendable {
+        case fixed(precision: @Sendable () -> Int, explicitPositiveSign: Bool)
     }
 
     let format: Format
@@ -131,14 +131,14 @@ public struct LogFloatFormatting {
         fixed(precision: 6, explicitPositiveSign: explicitPositiveSign)
     }
 
-    public static func fixed(precision: @autoclosure @escaping () -> Int, explicitPositiveSign: Bool = false) -> LogFloatFormatting {
+    public static func fixed(precision: @Sendable @autoclosure @escaping () -> Int, explicitPositiveSign: Bool = false) -> LogFloatFormatting {
         LogFloatFormatting(format: .fixed(precision: precision, explicitPositiveSign: explicitPositiveSign))
     }
 }
 
-public struct LogIntegerFormatting {
+public struct LogIntegerFormatting: Sendable {
     enum Format {
-        case decimal(minDigits: () -> Int, explicitPositiveSign: Bool)
+        case decimal(minDigits: @Sendable () -> Int, explicitPositiveSign: Bool)
     }
 
     let format: Format
@@ -151,13 +151,13 @@ public struct LogIntegerFormatting {
         decimal(explicitPositiveSign: explicitPositiveSign, minDigits: 0)
     }
 
-    public static func decimal(explicitPositiveSign: Bool = false, minDigits: @autoclosure @escaping () -> Int) -> LogIntegerFormatting {
+    public static func decimal(explicitPositiveSign: Bool = false, minDigits: @Sendable @autoclosure @escaping () -> Int) -> LogIntegerFormatting {
         LogIntegerFormatting(format: .decimal(minDigits: minDigits, explicitPositiveSign: explicitPositiveSign))
     }
 }
 
-@frozen public struct LogPrivacy: Equatable {
-    public enum Mask: Equatable {
+@frozen public struct LogPrivacy: Equatable, Sendable {
+    public enum Mask: Equatable, Sendable {
         case hash
         case none
     }

Sources/Logging/Locks.swift

@@ -28,9 +28,7 @@
 
 #if canImport(WASILibc)
 // No locking on WASILibc
-#else
-
-#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+#elseif canImport(Darwin)
 import Darwin
 #elseif os(Windows)
 import WinSDK
@@ -138,7 +136,9 @@ extension Lock {
 /// one used by NIO. On Windows, the lock is based on the substantially similar
 /// `SRWLOCK` type.
 internal final class ReadWriteLock {
-    #if os(Windows)
+    #if canImport(WASILibc)
+    // WASILibc is single threaded, provides no locks
+    #elseif os(Windows)
     fileprivate let rwlock: UnsafeMutablePointer<SRWLOCK> =
         UnsafeMutablePointer.allocate(capacity: 1)
     fileprivate var shared: Bool = true
@@ -149,7 +149,9 @@ internal final class ReadWriteLock {
 
     /// Create a new lock.
     public init() {
-        #if os(Windows)
+        #if canImport(WASILibc)
+        // WASILibc is single threaded, provides no locks
+        #elseif os(Windows)
         InitializeSRWLock(self.rwlock)
         #else
         let err = pthread_rwlock_init(self.rwlock, nil)
@@ -158,7 +160,9 @@ internal final class ReadWriteLock {
     }
 
     deinit {
-        #if os(Windows)
+        #if canImport(WASILibc)
+        // WASILibc is single threaded, provides no locks
+        #elseif os(Windows)
         // SRWLOCK does not need to be free'd
         #else
         let err = pthread_rwlock_destroy(self.rwlock)
@@ -172,7 +176,9 @@ internal final class ReadWriteLock {
     /// Whenever possible, consider using `withReaderLock` instead of this
     /// method and `unlock`, to simplify lock handling.
     public func lockRead() {
-        #if os(Windows)
+        #if canImport(WASILibc)
+        // WASILibc is single threaded, provides no locks
+        #elseif os(Windows)
         AcquireSRWLockShared(self.rwlock)
         self.shared = true
         #else
@@ -186,7 +192,9 @@ internal final class ReadWriteLock {
     /// Whenever possible, consider using `withWriterLock` instead of this
     /// method and `unlock`, to simplify lock handling.
     public func lockWrite() {
-        #if os(Windows)
+        #if canImport(WASILibc)
+        // WASILibc is single threaded, provides no locks
+        #elseif os(Windows)
         AcquireSRWLockExclusive(self.rwlock)
         self.shared = false
         #else
@@ -201,7 +209,9 @@ internal final class ReadWriteLock {
     /// instead of this method and `lockRead` and `lockWrite`, to simplify lock
     /// handling.
     public func unlock() {
-        #if os(Windows)
+        #if canImport(WASILibc)
+        // WASILibc is single threaded, provides no locks
+        #elseif os(Windows)
         if self.shared {
             ReleaseSRWLockShared(self.rwlock)
         } else {
@@ -261,4 +271,3 @@ extension ReadWriteLock {
         try self.withWriterLock(body)
     }
 }
-#endif

Sources/Logging/LogHandler.swift

@@ -113,7 +113,7 @@
 /// Please note that the above `LogHandler` will still pass the 'log level is a value' test above it iff the global log
 /// level has not been overridden. And most importantly it passes the requirement listed above: A change to the log
 /// level on one `Logger` should not affect the log level of another `Logger` variable.
-public protocol LogHandler {
+public protocol LogHandler: _SwiftLogSendableLogHandler {
     /// This method is called when a `LogHandler` must emit a log message. There is no need for the `LogHandler` to
     /// check if the `level` is above or below the configured `logLevel` as `Logger` already performed this check and
     /// determined that a message should be logged.
@@ -186,3 +186,11 @@ extension LogHandler {
                  line: line)
     }
 }
+
+// MARK: - Sendable support helpers
+
+#if compiler(>=5.6)
+@preconcurrency public protocol _SwiftLogSendableLogHandler: Sendable {}
+#else
+public protocol _SwiftLogSendableLogHandler {}
+#endif