Merge pull request #1429 from swiftlang/automerge/merge-main-2025-07-14_09-04

Merge `main` into `release/6.2`

Author: parkera

Benchmarks/Package.swift

@@ -37,7 +37,7 @@ let usePackage: UsePackage
 
 if let useLocalPackageEnv = Context.environment["SWIFTCI_USE_LOCAL_DEPS"], !useLocalPackageEnv.isEmpty {
     if useLocalPackageEnv == "1" {
-        usePackage = .useLocalPackage("..")
+        usePackage = .useLocalPackage("../..")
     } else {
         usePackage = .useLocalPackage(useLocalPackageEnv)
     }

CMakeLists.txt

@@ -94,7 +94,6 @@ list(APPEND CMAKE_MODULE_PATH ${SwiftFoundation_SOURCE_DIR}/cmake/modules)
 
 # Availability Macros (only applies to FoundationEssentials and FoundationInternationalization)
 set(_SwiftFoundation_BaseAvailability "macOS 15, iOS 18, tvOS 18, watchOS 11")
-set(_SwiftFoundation_macOS26Availability "macOS 26, iOS 26, tvOS 26, watchOS 26")
 set(_SwiftFoundation_FutureAvailability "macOS 10000, iOS 10000, tvOS 10000, watchOS 10000")
 
 # All versions to define for each availability name
@@ -106,13 +105,11 @@ list(APPEND _SwiftFoundation_versions
 
 # Each availability name to define
 list(APPEND _SwiftFoundation_availability_names
-    "FoundationPreview"
-    "FoundationSpan")
+    "FoundationPreview")
 
 # The aligned availability for each name (in the same order)
 list(APPEND _SwiftFoundation_availability_releases
-    ${_SwiftFoundation_BaseAvailability}
-    ${_SwiftFoundation_macOS26Availability})
+    ${_SwiftFoundation_BaseAvailability})
 
 foreach(version ${_SwiftFoundation_versions})
     foreach(name release IN ZIP_LISTS _SwiftFoundation_availability_names _SwiftFoundation_availability_releases)

Package.swift

@@ -8,7 +8,6 @@ import CompilerPluginSupport
 
 let availabilityTags: [_Availability] = [
     _Availability("FoundationPreview"), // Default FoundationPreview availability
-    _Availability("FoundationSpan", availability: .macOS26), // Availability of Span types
 ]
 let versionNumbers = ["6.0.2", "6.1", "6.2"]
 
@@ -108,10 +107,7 @@ let package = Package(
         // TestSupport (Internal)
         .target(
             name: "TestSupport",
-            dependencies: [
-                "FoundationEssentials",
-                "FoundationInternationalization",
-            ],
+            path: "Tests/TestSupport",
             cSettings: wasiLibcCSettings,
             swiftSettings: availabilityMacros + featureSettings
         ),

Proposals/0017-expanded-calendar-support.md

@@ -27,7 +27,7 @@ Foundation will add constants to support the new calendar types.
 
 Some calendars added by this proposal have a unique feature of "leap days", where two consecutive days can have the same numeric value. This new feature will have impact on APIs that search/match dates.
 
-This property will be called isAdhikaDay, to indicate it is used in Hindu calendars which are the only calendars that has this feature. More details about the naming is provided in the section `Alternatives considered` at the end of the document.
+This property will be called `isRepeatedDay`. More details about the naming is provided in the section `Alternatives considered` at the end of the document.
 
 ## Detailed design
 
@@ -86,7 +86,7 @@ Foundation will add new string constants for new calendar identifiers for NSCale
   }
 ```
 
-Following are the code changes required to support new calendar property isAdhikaDay
+Following are the code changes required to support new calendar property isRepeatedDay
 
 
 **Calendar.swift**
@@ -96,11 +96,20 @@ Following are the code changes required to support new calendar property isAdhik
 public enum Component : Sendable {
   // ...
   @available(FoundationPreview 6.2, *)
-  case isAdhikaDay
+  case isRepeatedDay
   // ....
 }
 ```
 
+**DateComponents.swift**
+
+```swift
+extension DateComponents {
+    @available(FoundationPreview 6.2, *)
+    public var isRepeatedDay: Bool? { get set }
+}
+```
+
 ## Impact on existing code
 
 Vietnamese and Korean calendars have no special considerations.
@@ -113,19 +122,17 @@ Calendars used in India are introducing the new field for the leap day. Clients
 var components = DateComponents()
 ```
 
-**Second**, the comparison for calendar dates will account for this field. Two dates differs if they don't have the same value for isAdhikaDay
+**Second**, the comparison for calendar dates will account for this field. Two dates differs if they don't have the same value for isRepeatedDay
 
 For example, the clients may currently use following check
 
 ```swift
 cal.compare(d1, d2)
 ```
 
-For Hindu calendars, this would only compare equal if they're both Adhika day or if they are both not. For non-Hindu calendars, isAdhikaDay property will be ignored.
-
-**Third**, the calendar date arithmetic will be updated to correctly calculate the dates regarding `adhikaDay`. When working with Hindu calendars, as the leap days can occur at any position, looking for next day would have to involve recalculation.
+For Hindu calendars, this would only compare equal if their year, month, day, and repeated day values are all the same. For non-Hindu calendars, isRepeatedDay property will be ignored.
 
-As a general rule, behavior of `isAdhikaDay` will replicate `isLeapMonth` in APIs doing matching and searching.
+As a general rule, behavior of `isRepeatedDay` will replicate `isLeapMonth` in APIs doing matching and searching.
 
 For example, let's explain what is the expected behavior in this API that enumerate the next date
 
@@ -144,17 +151,17 @@ Clients using this function to enumerate the next date after `date`, matching th
 
 * If start is on a leap day
 
-* `strict`: If components.isAdhikaDay is true, this gives you the next date that is also a leap day that shares the same day, month, year number (i.e. all those specified with the comps argument) as start. If only a subset of `DateComponents` is specified, for example only the month, this gives you the next date which is a leap day with same month. If no arguments are given for `DateComponents`, this gives the next date that is also a leap day. If components.isAdhikaDay is false, this function gives you the next date that matches the day/month/year number but one that is not a leap day.
+* `strict`: If components.isRepeatedDay is true, this gives you the next date that is also a leap day that shares the same day, month, year number (i.e. all those specified with the comps argument) as start. If only a subset of `DateComponents` is specified, for example only the month, this gives you the next date which is a leap day with same month. If no arguments are given for `DateComponents`, this gives the next date that is also a leap day. If components.isRepeatedDay is false, this function gives you the next date that matches the day/month/year number but one that is not a leap day.
 
 * If start is not on a leap day
 
-* `strict`: If components.isAdhikaDay is true, this gives you the next date that is a leap day that shares the same day, month, year number (i.e. all those specified with the comps argument) as start but a leap day. If components.isAdhikaDay is false, this function gives you the next date that matches the day/month/year number that is not a leap day.
+* `strict`: If components.isRepeatedDay is true, this gives you the next date that is a leap day that shares the same day, month, year number (i.e. all those specified with the comps argument) as start but a leap day. If components.isRepeatedDay is false, this function gives you the next date that matches the day/month/year number that is not a leap day.
 
 For the `direction` and `repeatedTimePolicy`:
 
 * `backward`: This flag does not affect how leap day search is handled, but merely changes the search direction so that it finds the match before start rather than after start.
 
-* `first`: If there are two or more matching dates, and all their components are the same, including isAdhikaDay, the function returns the first date.
+* `first`: If there are two or more matching dates, and all their components are the same, including isRepeatedDay, the function returns the first date.
 
 * `last`: Similar to `first`, but the function returns the last match.
 
@@ -178,6 +185,6 @@ public func dates(byAdding components: DateComponents,
 
 As mentioned before, the leap day is a unique feature of some of new calendars. It appears when a certain astronomical position of Sun and Moon happens which means it can appear on any date. That differs from Gregorian leap day of February 29th, which happens every four years (approximately) and it is always on the same day.
 
-This property will be called isAdhikaDay to clearly indicate it is related to Hindu lunisolar calendars. The alternative was to call it isLeapDay, but that may lead to confusion with Gregorian calendar
+This property will be called isRepeatedDay to clearly indicate it is a day that repeats. The alternatives were to call it isLeapDay which might lead to confusion with Gregorian calendar, or isAdhikaDay which would be unclear for developers unfamiliar with Hindu calendar terminology.
 
 Another point of discussion was whether to use Bengali vs Bangla and Oriya vs Odia. There has been an effort to stop using the older colloquial names Bengali and Oriya and to switch to the now-accepted names Bangla and Odia. While most of the attention has gone to the language names, the same naming should also be used for the calendar names, despite them receiving less attention.

Proposals/0024-CurrentBundle.md

@@ -1,7 +1,7 @@
 # Introduce `#bundle`
 
 
-* Proposal: [SF-0024](0024-filename.md)
+* Proposal: [SF-0024](0024-CurrentBundle.md)
 * Authors:[Matt Seaman](https://github.com/matthewseaman), [Andreas Neusuess](https://github.com/Tantalum73)
 * Review Manager: [Tina L](https://github.com/itingliu)
 * Implementation: https://github.com/swiftlang/swift-foundation/pull/1274

Sources/FoundationEssentials/AttributedString/AttributedString+Runs.swift

@@ -209,26 +209,24 @@ extension AttributedString.Runs.Index: Comparable {
     }
 }
 
-#if !FOUNDATION_FRAMEWORK
-@available(macOS, deprecated: 10000, introduced: 12, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
-@available(iOS, deprecated: 10000, introduced: 15, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
-@available(tvOS, deprecated: 10000, introduced: 15, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
-@available(watchOS, deprecated: 10000, introduced: 8, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
-@available(visionOS, deprecated: 10000, introduced: 1, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
+@available(macOS, deprecated: 26, introduced: 12, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
+@available(iOS, deprecated: 26, introduced: 15, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
+@available(tvOS, deprecated: 26, introduced: 15, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
+@available(watchOS, deprecated: 26, introduced: 8, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
+@available(visionOS, deprecated: 26, introduced: 1, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
 @available(*, deprecated, message: "AttributedString.Runs.Index should not be used as a Strideable and should instead be offset using the API provided by AttributedString.Runs")
 extension AttributedString.Runs.Index: Strideable {
     public func distance(to other: Self) -> Int {
         // This isn't perfect (since two non-sliced indices might have other sliced runs between them) but checking is better than nothing
         precondition(!self._withinDiscontiguous && !other._withinDiscontiguous, "AttributedString.Runs.Index's Strideable conformance may not be used with discontiguous sliced runs")
         return other._runOffset - self._runOffset
     }
-        
+    
     public func advanced(by n: Int) -> Self {
         precondition(!self._withinDiscontiguous, "AttributedString.Runs.Index's Strideable conformance may not be used with discontiguous sliced runs")
         return Self(_runOffset: self._runOffset + n, withinDiscontiguous: false)
     }
 }
-#endif
 
 @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
 extension Range<AttributedString.Runs.Index> {
@@ -332,12 +330,18 @@ extension AttributedString.Runs: BidirectionalCollection {
         }
     }
 
-    #if !FOUNDATION_FRAMEWORK
     @_alwaysEmitIntoClient
     public func distance(from start: Index, to end: Index) -> Int {
+        #if FOUNDATION_FRAMEWORK
+        if #available(macOS 26, iOS 26, tvOS 26, watchOS 26, visionOS 26, *) {
+            _distance(from: start, to: end)
+        } else {
+            start.distance(to: end)
+        }
+        #else
         _distance(from: start, to: end)
+        #endif
     }
-    #endif
 
     @available(FoundationPreview 6.2, *)
     @usableFromInline

Sources/FoundationEssentials/Calendar/Calendar.swift

@@ -248,6 +248,7 @@ public struct Calendar : Hashable, Equatable, Sendable {
         package static let timeZone = ComponentSet(rawValue: 1 << 15)
         package static let isLeapMonth = ComponentSet(rawValue: 1 << 16)
         package static let dayOfYear = ComponentSet(rawValue: 1 << 18)
+        package static let isRepeatedDay = ComponentSet(rawValue: 1 << 19)
 
         package var count: Int {
             rawValue.nonzeroBitCount
@@ -272,6 +273,7 @@ public struct Calendar : Hashable, Equatable, Sendable {
             if contains(.calendar) { result.insert(.calendar) }
             if contains(.timeZone) { result.insert(.timeZone) }
             if contains(.isLeapMonth) { result.insert(.isLeapMonth) }
+            if contains(.isRepeatedDay) { result.insert(.isRepeatedDay) }
             if contains(.dayOfYear) { result.insert(.dayOfYear) }
             return result
         }
@@ -293,8 +295,9 @@ public struct Calendar : Hashable, Equatable, Sendable {
             if self.contains(.yearForWeekOfYear) { return .yearForWeekOfYear }
             if self.contains(.nanosecond) { return .nanosecond }
 
-            // The algorithms that call this function assume that isLeapMonth counts as a 'highest unit set', but the order is after nanosecond.
+            // The algorithms that call this function assume that isLeapMonth and isRepeatedDay can count as 'highest unit set', but they are ordered after nanosecond.
             if self.contains(.isLeapMonth) { return .isLeapMonth }
+            if self.contains(.isRepeatedDay) { return .isRepeatedDay }
 
             // The calendar and timeZone properties do not count as a 'highest unit set', since they are not ordered in time like the others are.
             return nil
@@ -325,7 +328,8 @@ public struct Calendar : Hashable, Equatable, Sendable {
         case timeZone
         @available(macOS 14, iOS 17, tvOS 17, watchOS 10, *)
         case isLeapMonth
-        
+        @available(FoundationPreview 6.2, *)
+        case isRepeatedDay
         @available(macOS 15, iOS 18, tvOS 18, watchOS 11, *)
         case dayOfYear
 
@@ -349,6 +353,7 @@ public struct Calendar : Hashable, Equatable, Sendable {
             case .calendar: return ComponentSet.calendar.rawValue
             case .timeZone: return ComponentSet.timeZone.rawValue
             case .isLeapMonth: return ComponentSet.isLeapMonth.rawValue
+            case .isRepeatedDay: return ComponentSet.isRepeatedDay.rawValue
             }
         }
 
@@ -372,6 +377,7 @@ public struct Calendar : Hashable, Equatable, Sendable {
             case .calendar: "calendar"
             case .timeZone: "timeZone"
             case .isLeapMonth: "isLeapMonth"
+            case .isRepeatedDay: "isRepeatedDay"
             }
         }
     }
@@ -694,6 +700,11 @@ public struct Calendar : Hashable, Equatable, Sendable {
         return dc
     }
 
+    /// True if this is a lunisolar calendar that repeats the month number for a leap month, false otherwise.
+    var hasRepeatingMonths: Bool {
+        return identifier == .chinese || identifier == .dangi || identifier == .gujarati || identifier == .kannada || identifier == .marathi || identifier == .telugu || identifier == .vietnamese || identifier == .vikram
+    }
+
     /// Returns all the date components of a date, as if in a given time zone (instead of the `Calendar` time zone).
     ///
     /// The time zone overrides the time zone of the `Calendar` for the purposes of this calculation.
@@ -809,7 +820,7 @@ public struct Calendar : Hashable, Equatable, Sendable {
         }
 
         switch component {
-        case .calendar, .timeZone, .isLeapMonth:
+        case .calendar, .timeZone, .isLeapMonth, .isRepeatedDay:
             return .orderedSame
         case .day, .hour:
             // Day here so we don't assume that time zone fall back situations don't fall back into a previous day
@@ -902,6 +913,9 @@ public struct Calendar : Hashable, Equatable, Sendable {
         let comp1 = self.dateComponents(Set(units), from: date1)
         let comp2 = self.dateComponents(Set(units), from: date2)
 
+        // check if this is a lunisolar calendar that repeats the day number for a leap day
+        let hasRepeatingDays = identifier == .gujarati || identifier == .kannada || identifier == .marathi || identifier == .telugu || identifier == .vikram
+
         for c in units {
             guard let value1 = comp1.value(for: c), let value2 = comp2.value(for: c) else {
                 return fallback
@@ -913,7 +927,7 @@ public struct Calendar : Hashable, Equatable, Sendable {
                 return .orderedAscending
             }
 
-            if c == .month && identifier == .chinese {
+            if c == .month && hasRepeatingMonths {
                 let leap1 = comp1.isLeapMonth ?? false
                 let leap2 = comp2.isLeapMonth ?? false
 
@@ -924,6 +938,17 @@ public struct Calendar : Hashable, Equatable, Sendable {
                 }
             }
 
+            if c == .day && hasRepeatingDays {
+                let repeated1 = comp1.isRepeatedDay ?? false
+                let repeated2 = comp2.isRepeatedDay ?? false
+
+                if !repeated1 && repeated2 {
+                    return .orderedAscending
+                } else if repeated1 && !repeated2 {
+                    return .orderedDescending
+                }
+            }
+
             if component == c {
                 return .orderedSame
             }
@@ -1341,6 +1366,12 @@ public struct Calendar : Hashable, Equatable, Sendable {
             comp.isLeapMonth = _dateComponents(.month, from: date).isLeapMonth
         }
 
+        if components.isRepeatedDay != nil {
+            // `isRepeatedDay` isn't part of `actualUnits`, so we have to retrieve
+            // it separately
+            comp.isRepeatedDay = _dateComponents(.isRepeatedDay, from: date).isRepeatedDay
+        }
+
         // Apply an epsilon to comparison of nanosecond values
         if let nanosecond = comp.nanosecond, let tempNanosecond = tempComp.nanosecond {
             if labs(CLong(nanosecond - tempNanosecond)) > 500 {