Parity: TimeZone.local, TimeZone.timeZoneDataVersion

Add __NSLocalTimeZone; the name is chosen so as to be NSCoding-compatible with Darwin. Make sure NSTimeZone.local and TimeZone.autoupdatingCurrent return it.

Implement .timeZoneDataVersion the same way as it is in Darwin.

Re-enable the setter for .abbreviationDictionary.

Author: millenomi

CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h

@@ -392,6 +392,7 @@ CF_EXPORT _Nullable CFErrorRef CFReadStreamCopyError(CFReadStreamRef _Null_unspe
 CF_EXPORT _Nullable CFErrorRef CFWriteStreamCopyError(CFWriteStreamRef _Null_unspecified stream);
 
 CF_CROSS_PLATFORM_EXPORT Boolean _CFBundleSupportsFHSBundles(void);
+CF_CROSS_PLATFORM_EXPORT CFStringRef __CFTimeZoneCopyDataVersionString(void);
 
 // https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
 // Version 0.8

CoreFoundation/NumberDate.subproj/CFTimeZone.c

@@ -1537,4 +1537,8 @@ static CFDictionaryRef __CFTimeZoneCopyCompatibilityDictionary(void) {
     return dict;
 }
 
-
+CF_CROSS_PLATFORM_EXPORT CFStringRef __CFTimeZoneCopyDataVersionString(void) {
+    UErrorCode err = U_ZERO_ERROR;
+    const char *cstr = ucal_getTZDataVersion(&err);
+    return (U_SUCCESS(err)) ? CFStringCreateWithCString(kCFAllocatorSystemDefault, cstr, kCFStringEncodingUTF8) : CFRetain(CFSTR(""));
+}

Foundation/NSTimeZone.swift

@@ -178,9 +178,6 @@ open class NSTimeZone : NSObject, NSCopying, NSSecureCoding, NSCoding {
         }
         return Date(timeIntervalSinceReferenceDate: CFTimeZoneGetNextDaylightSavingTimeTransition(_cfObject, aDate.timeIntervalSinceReferenceDate))
     }
-}
-
-extension NSTimeZone {
 
     open class var system: TimeZone {
         return CFTimeZoneCopySystem()._swiftObject
@@ -199,7 +196,9 @@ extension NSTimeZone {
         }
     }
 
-    open class var local: TimeZone { NSUnimplemented() }
+    open class var local: TimeZone {
+        return TimeZone(adoptingReference: __NSLocalTimeZone.shared, autoupdating: true)
+    }
 
     open class var knownTimeZoneNames: [String] {
         guard let knownNames = CFTimeZoneCopyKnownNames() else { return [] }
@@ -212,12 +211,17 @@ extension NSTimeZone {
             return dictionary._nsObject._bridgeToSwift() as! [String : String]
         }
         set {
-            // CFTimeZoneSetAbbreviationDictionary(newValue._cfObject)
-            NSUnimplemented()
+            CFTimeZoneSetAbbreviationDictionary(newValue._cfObject)
         }
     }
 
-    open class var timeZoneDataVersion: String { NSUnimplemented() }
+    open class var timeZoneDataVersion: String {
+        #if os(Windows)
+            return "" // We do not source timezone data from ICU. The empty string is what Darwin would return if ICU isn't able to give a time zone data version.
+        #else
+            return __CFTimeZoneCopyDataVersionString()._swiftObject
+        #endif
+    }
 
     open var secondsFromGMT: Int {
         let currentDate = Date()
@@ -296,3 +300,53 @@ extension NSTimeZone {
 extension NSNotification.Name {
     public static let NSSystemTimeZoneDidChange = NSNotification.Name(rawValue: kCFTimeZoneSystemTimeZoneDidChangeNotification._swiftObject)
 }
+
+internal class __NSLocalTimeZone: NSTimeZone {
+    static var shared = __NSLocalTimeZone()
+    
+    private init() {
+        super.init(_name: "GMT+0000")
+    }
+    
+    public convenience required init?(coder aDecoder: NSCoder) {
+        // We do not encode details of the local time zone, merely the placeholder object.
+        self.init()
+    }
+    
+    override func encode(with aCoder: NSCoder) {
+        // We do not encode details of the local time zone, merely the placeholder object.
+    }
+    
+    private var system: NSTimeZone {
+        return NSTimeZone.system._nsObject
+    }
+    
+    override var name: String { return system.name }
+    override var data: Data { return system.data }
+    override func secondsFromGMT(for aDate: Date) -> Int {
+        return system.secondsFromGMT(for: aDate)
+    }
+    override func abbreviation(for aDate: Date) -> String? {
+        return system.abbreviation(for: aDate)
+    }
+    override func isDaylightSavingTime(for aDate: Date) -> Bool {
+        return system.isDaylightSavingTime(for: aDate)
+    }
+    override func daylightSavingTimeOffset(for aDate: Date) -> TimeInterval {
+        return system.daylightSavingTimeOffset(for: aDate)
+    
+    }
+    override func nextDaylightSavingTimeTransition(after aDate: Date) -> Date? {
+        return system.nextDaylightSavingTimeTransition(after: aDate)
+    }
+    override func localizedName(_ style: NSTimeZone.NameStyle, locale: Locale?) -> String? {
+        return system.localizedName(style, locale: locale)
+    }
+    override var description: String {
+        return "Local Time Zone (\(system.description))"
+    }
+    
+    override func copy(with zone: NSZone? = nil) -> Any {
+        return self
+    }
+}

Foundation/TimeZone.swift

@@ -49,8 +49,7 @@ public struct TimeZone : Hashable, Equatable, ReferenceConvertible {
     ///
     /// The autoupdating time zone only compares equal to itself.
     public static var autoupdatingCurrent : TimeZone {
-        // swift-corelibs-foundation does not yet support autoupdating, but we can return the current time zone (which will not change).
-        return TimeZone(adoptingReference: __NSTimeZoneAutoupdating(), autoupdating: true)
+        return NSTimeZone.local
     }
 
     // MARK: -
@@ -118,7 +117,7 @@ public struct TimeZone : Hashable, Equatable, ReferenceConvertible {
         }
     }
 
-    private init(adoptingReference reference: NSTimeZone, autoupdating: Bool) {
+    internal init(adoptingReference reference: NSTimeZone, autoupdating: Bool) {
         // this path is only used for types we do not need to copy (we are adopting the ref)
         _wrapped = reference
         _autoupdating = autoupdating

TestFoundation/TestTimeZone.swift

@@ -10,33 +10,19 @@
 import CoreFoundation
 
 class TestTimeZone: XCTestCase {
-
-    static var allTests: [(String, (TestTimeZone) -> () throws -> Void)] {
-        var tests: [(String, (TestTimeZone) -> () throws -> Void)] = [
-            ("test_abbreviation", test_abbreviation),
-
-            // Disabled because `CFTimeZoneSetAbbreviationDictionary()` attempts
-            // to release non-CF objects while removing values from
-            // `__CFTimeZoneCache`
-            // ("test_abbreviationDictionary", test_abbreviationDictionary),
-
-            ("test_changingDefaultTimeZone", test_changingDefaultTimeZone),
-            ("test_computedPropertiesMatchMethodReturnValues", test_computedPropertiesMatchMethodReturnValues),
-            ("test_initializingTimeZoneWithOffset", test_initializingTimeZoneWithOffset),
-            ("test_initializingTimeZoneWithAbbreviation", test_initializingTimeZoneWithAbbreviation),
-            ("test_localizedName", test_localizedName),
-            ("test_customMirror", test_tz_customMirror),
-            ("test_knownTimeZones", test_knownTimeZones),
-            ("test_systemTimeZoneName", test_systemTimeZoneName),
-        ]
-
-#if !os(Windows)
-      tests.append(contentsOf: [
-            ("test_systemTimeZoneUsesSystemTime", test_systemTimeZoneUsesSystemTime),
-      ])
-#endif
-
-        return tests
+    
+    var initialDefaultTimeZone: TimeZone?
+    
+    override func setUp() {
+        initialDefaultTimeZone = NSTimeZone.default
+        super.setUp()
+    }
+    
+    override func tearDown() {
+        super.tearDown()
+        if let tz = initialDefaultTimeZone {
+            NSTimeZone.default = tz
+        }
     }
 
     func test_abbreviation() {
@@ -220,4 +206,56 @@ class TestTimeZone: XCTestCase {
         XCTAssertEqual(CFStringGetLength(timeZoneName), TimeZone.current.identifier.count)
         XCTAssertEqual(CFStringGetLength(timeZoneName), createdTimeZone.identifier.count)
     }
+    
+    func test_autoupdatingTimeZone() {
+        let system = NSTimeZone.system
+        let date = Date()
+        
+        for zone in [NSTimeZone.local, TimeZone.autoupdatingCurrent] {
+            XCTAssertEqual(zone.identifier, system.identifier)
+            XCTAssertEqual(zone.secondsFromGMT(for: date), system.secondsFromGMT(for: date))
+            XCTAssertEqual(zone.abbreviation(for: date), system.abbreviation(for: date))
+            XCTAssertEqual(zone.isDaylightSavingTime(for: date), system.isDaylightSavingTime(for: date))
+            XCTAssertEqual(zone.daylightSavingTimeOffset(for: date), system.daylightSavingTimeOffset(for: date))
+            XCTAssertEqual(zone.nextDaylightSavingTimeTransition(after: date), system.nextDaylightSavingTimeTransition(after: date))
+            
+            for style in [NSTimeZone.NameStyle.standard,
+                          NSTimeZone.NameStyle.shortStandard,
+                          NSTimeZone.NameStyle.daylightSaving,
+                          NSTimeZone.NameStyle.shortDaylightSaving,
+                          NSTimeZone.NameStyle.generic,
+                          NSTimeZone.NameStyle.shortGeneric,] {
+                XCTAssertEqual(zone.localizedName(for: style, locale: NSLocale.system), system.localizedName(for: style, locale: NSLocale.system), "For style: \(style)")
+            }
+        }
+    }
+    
+    static var allTests: [(String, (TestTimeZone) -> () throws -> Void)] {
+        var tests: [(String, (TestTimeZone) -> () throws -> Void)] = [
+            ("test_abbreviation", test_abbreviation),
+            
+            // Disabled because `CFTimeZoneSetAbbreviationDictionary()` attempts
+            // to release non-CF objects while removing values from
+            // `__CFTimeZoneCache`
+            // ("test_abbreviationDictionary", test_abbreviationDictionary),
+            
+            ("test_changingDefaultTimeZone", test_changingDefaultTimeZone),
+            ("test_computedPropertiesMatchMethodReturnValues", test_computedPropertiesMatchMethodReturnValues),
+            ("test_initializingTimeZoneWithOffset", test_initializingTimeZoneWithOffset),
+            ("test_initializingTimeZoneWithAbbreviation", test_initializingTimeZoneWithAbbreviation),
+            ("test_localizedName", test_localizedName),
+            ("test_customMirror", test_tz_customMirror),
+            ("test_knownTimeZones", test_knownTimeZones),
+            ("test_systemTimeZoneName", test_systemTimeZoneName),
+            ("test_autoupdatingTimeZone", test_autoupdatingTimeZone),
+        ]
+        
+        #if !os(Windows)
+        tests.append(contentsOf: [
+            ("test_systemTimeZoneUsesSystemTime", test_systemTimeZoneUsesSystemTime),
+            ])
+        #endif
+        
+        return tests
+    }
 }