Always extract new components

When creating a new fixed value from components, always extract the components via the Calendar to use as the Fixed value's model. This way any missing-but-not-required (ie, lenient) units will be filled in.

Fixes #82

Author: davedelong

Sources/Time/4-Fixed Values/Fixed.swift

@@ -88,10 +88,10 @@ public struct Fixed<Granularity: Unit & LTOEEra>: Sendable {
     /// - Parameter region: The `Region` in which to interpret the date components
     /// - Parameter strictDateComponents: The `DateComponents` describing the desired calendrical date
     public init(region: Region, strictDateComponents: DateComponents) throws {
-        let date = try region.calendar.exactDate(from: strictDateComponents,
-                                                 in: region.timeZone,
-                                                 matching: Self.representedComponents)
-        self.init(region: region, instant: Instant(date: date), components: strictDateComponents)
+        let (date, actualComponents) = try region.calendar.exactDate(from: strictDateComponents,
+                                                                     in: region.timeZone,
+                                                                     matching: Self.representedComponents)
+        self.init(region: region, instant: Instant(date: date), components: actualComponents)
     }
 
 }

Sources/Time/Internals/Time+Calendar.swift

@@ -25,19 +25,19 @@ extension Calendar {
         return [.era]
     }
 
-    internal func exactDate(from components: DateComponents, in timeZone: TimeZone, matching: Set<Calendar.Component>) throws -> Date {
-        var restricted = try components.requireAndRestrict(to: matching, lenient: self.lenientUnitsForFixedTimePeriods)
-        restricted.timeZone = timeZone
+    internal func exactDate(from components: DateComponents, in timeZone: TimeZone, matching: Set<Calendar.Component>) throws -> (Date, DateComponents) {
+        var restrictedComponents = try components.requireAndRestrict(to: matching, lenient: self.lenientUnitsForFixedTimePeriods)
+        restrictedComponents.timeZone = timeZone
 
-        guard let proposed = self.date(from: restricted) else {
-            let r = Region(calendar: self, timeZone: self.timeZone, locale: self.locale ?? .current)
-            throw TimeError.invalidDateComponents(restricted, in: r)
+        guard let proposedDate = self.date(from: restrictedComponents) else {
+            let r = Region(calendar: self, timeZone: timeZone, locale: self.locale ?? .current)
+            throw TimeError.invalidDateComponents(restrictedComponents, in: r)
         }
 
-        let proposedComponents = self.dateComponents(in: timeZone, from: proposed)
+        let proposedComponents = self.dateComponents(in: timeZone, from: proposedDate)
 
-        if isEraRelevant == false && restricted.era == nil {
-            restricted.era = proposedComponents.era
+        if isEraRelevant == false && restrictedComponents.era == nil {
+            restrictedComponents.era = proposedComponents.era
         }
 
         for unit in matching {
@@ -48,13 +48,15 @@ extension Calendar {
             // appears to be restricted to within about 24,000 nanoseconds
             if unit == .nanosecond { continue }
 
-            guard proposedComponents.value(for: unit) == restricted.value(for: unit) else {
+            guard proposedComponents.value(for: unit) == restrictedComponents.value(for: unit) else {
                 let r = Region(calendar: self, timeZone: self.timeZone, locale: self.locale ?? .current)
-                throw TimeError.invalidDateComponents(restricted, in: r)
+                throw TimeError.invalidDateComponents(restrictedComponents, in: r)
             }
         }
 
-        return proposed
+        let actualComponents = try! proposedComponents.requireAndRestrict(to: matching, lenient: [])
+        
+        return (proposedDate, actualComponents)
     }
 
     internal func range(of unit: Calendar.Component, containing date: Date) -> Range<Date> {

Tests/TimeTests/FixedTests.swift

@@ -16,8 +16,9 @@ class FixedTests: XCTestCase {
         ("testAddingComponents", testAddingComponents),
     ]
 
-    func testInitializingGregorianDateWithoutEraSucceeds() {
-        XCTAssertNoThrow(try Fixed<Day>(region: .posix, year: 1970, month: 4, day: 1))
+    func testInitializingGregorianDateWithoutEraSucceeds() throws {
+        let day = try Fixed<Day>(region: .posix, year: 1970, month: 4, day: 1)
+        XCTAssertEqual(day.era, 1)
     }
 
     func testInitializingGregorianDateWithEraSucceeds() {

Tests/TimeTests/ReportedBugs.swift

@@ -64,4 +64,9 @@ class ReportedBugs: XCTestCase {
         XCTAssertEqual(formattedGregorian, "1")
         XCTAssertEqual(formattedISO8601, "7")
     }
+    
+    func testValuesWithoutErasStillHaveThem_GH82() throws {
+        let day = try Fixed(region: .posix, year: 2024, month: 4, day: 7)
+        XCTAssertEqual(day.era, 1)
+    }
 }