Merge branch 'main' into stateful-surpasses

Author: poulsbo

.github/pull_request_template.md

@@ -5,4 +5,8 @@ Reminder: try to use [Conventional Comments](https://conventionalcomments.org/)
 
 Please see https://github.com/unicode-org/icu4x/blob/main/CONTRIBUTING.md for general
 information on contributing to ICU4X.
--->
+-->
+
+## Changelog
+
+<!-- Please fill in according to documents/process/changelog.md -->

.github/workflows/changelog.yml

@@ -0,0 +1,73 @@
+# This file is part of ICU4X. For terms of use, please see the file
+# called LICENSE at the top level of the ICU4X source tree
+# (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+name: Changelog Check
+
+on:
+  merge_group:
+  pull_request:
+    types: [opened, reopened, synchronize, edited]
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}"
+  # Only one per PR.
+  cancel-in-progress: true
+
+jobs:
+  changelog:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check for Changelog section
+        shell: python
+        env:
+          PR_BODY: ${{ github.event.pull_request.body }}
+        run: |
+          import os
+          import sys
+          import re
+
+          body = os.environ.get("PR_BODY", "")
+          
+          # Remove HTML comments
+          body = re.sub(r'<!--.*?-->', '', body, flags=re.DOTALL)
+          
+          # Find # Changelog section header (case-insensitive)
+          header_match = re.search(r'^##\s*Changelog\b(.*?)$', body, re.IGNORECASE | re.MULTILINE)
+          
+          if not header_match:
+              print("::error::No '## Changelog' section found in the PR description.")
+              print("Please add a '## Changelog' section to your PR body.")
+              sys.exit(1)
+          
+          header_suffix = header_match.group(1).strip()
+          
+          # Check for escape hatches in the header line
+          # Allow: # Changelog (N/A), # Changelog: N/A, # Changelog: TBD, etc.
+          if re.search(r'\(N/A\)|:\s*N/A|:\s*TBD', header_suffix, re.IGNORECASE):
+              print("Changelog check passed (opted out or deferred via header).")
+              sys.exit(0)
+          
+          # Extract content after the header until the next header or end of string
+          content_start = header_match.end()
+          # We look for the next header by looking for '^#+\s+' after a newline
+          next_header_match = re.search(r'\n#+\s+', body[content_start:])
+          if next_header_match:
+              content = body[content_start:content_start + next_header_match.start()]
+          else:
+              content = body[content_start:]
+          
+          content = content.strip()
+          
+          # Also check if the content itself starts with N/A or TBD
+          if re.match(r'^(N/A|TBD)\b', content, re.IGNORECASE):
+              print("Changelog check passed (opted out or deferred in content).")
+              sys.exit(0)
+          
+          if not content:
+              print("::error::The '## Changelog' section is empty.")
+              print("Please provide a changelog entry, or use '## Changelog (N/A)' or '## Changelog: TBD' if appropriate.")
+              sys.exit(1)
+          
+          print("Changelog check passed.")
+

components/calendar/src/any_calendar.rs

@@ -34,7 +34,6 @@ macro_rules! make_any_calendar {
     ) => {
         $(#[$any_calendar_meta])*
         #[derive(Debug, Clone)]
-        // TODO(#3469): Decide on the best way to implement Ord.
         pub enum $any_calendar_ident {
             $(
                 #[doc = concat!("A [`", stringify!($ty), "`] calendar")]
@@ -102,7 +101,7 @@ macro_rules! make_any_calendar {
         impl $crate::Calendar for $any_calendar_ident {
             type DateInner = $any_date_ident;
             type Year = $crate::types::YearInfo;
-            type DifferenceError = $crate::error::MismatchedCalendarError;
+            type DateCompatibilityError = $crate::error::MismatchedCalendarError;
 
             fn from_codes(
                 &self,
@@ -351,24 +350,39 @@ macro_rules! make_any_calendar {
                 date1: &Self::DateInner,
                 date2: &Self::DateInner,
                 options: $crate::options::DateDifferenceOptions,
-            ) -> Result<$crate::types::DateDuration, Self::DifferenceError> {
-                let Ok(r) = match (self, date1, date2) {
+            ) -> $crate::types::DateDuration {
+                match (self, date1, date2) {
                     $(
-                        (Self::$variant(ref c1), $any_date_ident::$variant(d1, q1), $any_date_ident::$variant(d2, q2)) if AnyCalendarable::identity(c1) == *q1 && q1 == q2 => {
-                            c1.until(d1, d2, options)
+                        (Self::$variant(ref c), $any_date_ident::$variant(d1, q1), $any_date_ident::$variant(d2, q2)) if AnyCalendarable::identity(c) == *q1 && q1 == q2 => {
+                            c.until(d1, d2, options)
                         }
                     )+
                     $(
                         #[allow(deprecated)]
-                        (Self::$deprecated_variant(ref c1), $any_date_ident::$deprecated_variant(d1, q1), $any_date_ident::$deprecated_variant(d2, q2)) if AnyCalendarable::identity(c1) == *q1 && q1 == q2 => {
-                            c1.until(d1, d2, options)
+                        (Self::$deprecated_variant(ref c), $any_date_ident::$deprecated_variant(d1, q1), $any_date_ident::$deprecated_variant(d2, q2)) if AnyCalendarable::identity(c) == *q1 && q1 == q2  => {
+                            c.until(d1, d2, options)
                         }
                     )*
-                    _ => {
-                        return Err($crate::error::MismatchedCalendarError);
-                    }
-                };
-                Ok(r)
+                    // This is only reached from misuse of from_raw, a semi-internal api
+                    _ => panic!(concat!(stringify!($any_calendar_ident), " with mismatched date type")),
+                }
+            }
+
+            fn check_date_compatibility(&self, other: &Self) -> Result<(), Self::DateCompatibilityError> {
+                match (self, other) {
+                    $(
+                        (Self::$variant(ref c1), Self::$variant(ref c2)) if c1.check_date_compatibility(c2).is_ok() => {
+                            Ok(())
+                        }
+                    )+
+                    $(
+                        #[allow(deprecated)]
+                        (Self::$deprecated_variant(ref c1), Self::$deprecated_variant(ref c2)) if c1.check_date_compatibility(c2).is_ok() => {
+                            Ok(())
+                        }
+                    )*
+                    _ => Err($crate::error::MismatchedCalendarError),
+                }
             }
 
             fn debug_name(&self) -> &'static str {
@@ -732,7 +746,7 @@ impl AnyCalendar {
 impl<C: AsCalendar<Calendar = AnyCalendar>> Date<C> {
     /// Convert this `Date<AnyCalendar>` to another [`AnyCalendar`], if conversion is needed
     pub fn convert_any<'a>(&self, calendar: &'a AnyCalendar) -> Date<Ref<'a, AnyCalendar>> {
-        if calendar == self.calendar() {
+        if calendar.check_date_compatibility(self.calendar()).is_ok() {
             Date::from_raw(*self.inner(), Ref(calendar))
         } else {
             self.to_calendar(Ref(calendar))
@@ -1406,7 +1420,7 @@ mod tests {
 
         assert_eq!(
             (month, day),
-            (date.month().as_input(), date.day_of_month().0),
+            (date.month().to_input(), date.day_of_month().0),
             "Failed to roundtrip for calendar {}",
             calendar.debug_name()
         );

components/calendar/src/cal/abstract_gregorian.rs

@@ -84,7 +84,7 @@ impl<Y: GregorianYears> crate::cal::scaffold::UnstableSealed for AbstractGregori
 impl<Y: GregorianYears> Calendar for AbstractGregorian<Y> {
     type DateInner = ArithmeticDate<AbstractGregorian<IsoEra>>;
     type Year = EraYear;
-    type DifferenceError = core::convert::Infallible;
+    type DateCompatibilityError = core::convert::Infallible;
 
     fn from_codes(
         &self,
@@ -159,8 +159,15 @@ impl<Y: GregorianYears> Calendar for AbstractGregorian<Y> {
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateDifferenceOptions,
-    ) -> Result<types::DateDuration, Self::DifferenceError> {
-        Ok(date1.until(date2, &AbstractGregorian(IsoEra), options))
+    ) -> types::DateDuration {
+        date1.until(date2, &AbstractGregorian(IsoEra), options)
+    }
+
+    fn check_date_compatibility(&self, other: &Self) -> Result<(), Self::DateCompatibilityError> {
+        // The GregorianYears generic only affects constructors and year_info,
+        // it does not affect date identity.
+        let _ignored = other;
+        Ok(())
     }
 
     fn year_info(&self, date: &Self::DateInner) -> Self::Year {
@@ -212,7 +219,7 @@ macro_rules! impl_with_abstract_gregorian {
         impl crate::Calendar for $cal_ty {
             type DateInner = $inner_date_ty;
             type Year = types::EraYear;
-            type DifferenceError = core::convert::Infallible;
+            type DateCompatibilityError = core::convert::Infallible;
 
             fn from_codes(
                 &self,
@@ -304,12 +311,23 @@ macro_rules! impl_with_abstract_gregorian {
                 date1: &Self::DateInner,
                 date2: &Self::DateInner,
                 options: crate::options::DateDifferenceOptions,
-            ) -> Result<crate::types::DateDuration, Self::DifferenceError> {
+            ) -> crate::types::DateDuration {
                 let $self_ident = self;
                 crate::cal::abstract_gregorian::AbstractGregorian($eras_expr)
                     .until(&date1.0, &date2.0, options)
             }
 
+            fn check_date_compatibility(
+                &self,
+                other: &Self,
+            ) -> Result<(), Self::DateCompatibilityError> {
+                let $self_ident = self;
+                let c1 = crate::cal::abstract_gregorian::AbstractGregorian($eras_expr);
+                let $self_ident = other;
+                let c2 = crate::cal::abstract_gregorian::AbstractGregorian($eras_expr);
+                c1.check_date_compatibility(&c2)
+            }
+
             fn year_info(&self, date: &Self::DateInner) -> Self::Year {
                 let $self_ident = self;
                 crate::cal::abstract_gregorian::AbstractGregorian($eras_expr).year_info(&date.0)

components/calendar/src/cal/coptic.rs

@@ -130,7 +130,7 @@ impl crate::cal::scaffold::UnstableSealed for Coptic {}
 impl Calendar for Coptic {
     type DateInner = CopticDateInner;
     type Year = types::EraYear;
-    type DifferenceError = core::convert::Infallible;
+    type DateCompatibilityError = core::convert::Infallible;
 
     fn from_codes(
         &self,
@@ -201,8 +201,12 @@ impl Calendar for Coptic {
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateDifferenceOptions,
-    ) -> Result<types::DateDuration, Self::DifferenceError> {
-        Ok(date1.0.until(&date2.0, self, options))
+    ) -> types::DateDuration {
+        date1.0.until(&date2.0, self, options)
+    }
+
+    fn check_date_compatibility(&self, &Self: &Self) -> Result<(), Self::DateCompatibilityError> {
+        Ok(())
     }
 
     fn year_info(&self, date: &Self::DateInner) -> Self::Year {

components/calendar/src/cal/east_asian_traditional.rs

@@ -203,6 +203,15 @@ pub trait Rules: Clone + core::fmt::Debug + crate::cal::scaffold::UnstableSealed
         Err(EcmaReferenceYearError::Unimplemented)
     }
 
+    /// The error that is returned by [`Self::check_date_compatibility`].
+    ///
+    /// Set this to [`core::convert::Infallible`] if the type is a singleton or
+    /// the parameterization does not affect calendar semantics.
+    type DateCompatibilityError: core::fmt::Debug;
+
+    /// Checks whether two [`Rules`] values are equal for the purpose of [`Date`] interaction.
+    fn check_date_compatibility(&self, other: &Self) -> Result<(), Self::DateCompatibilityError>;
+
     /// The debug name for the calendar defined by these [`Rules`].
     fn debug_name(&self) -> &'static str {
         "EastAsianTraditional (custom)"
@@ -302,6 +311,12 @@ impl Rules for China {
         ecma_reference_year_common(month, day, EastAsianCalendarKind::Chinese)
     }
 
+    type DateCompatibilityError = core::convert::Infallible;
+
+    fn check_date_compatibility(&self, &Self: &Self) -> Result<(), Self::DateCompatibilityError> {
+        Ok(())
+    }
+
     fn calendar_algorithm(&self) -> Option<CalendarAlgorithm> {
         Some(CalendarAlgorithm::Chinese)
     }
@@ -437,6 +452,12 @@ impl Rules for Korea {
         ecma_reference_year_common(month, day, EastAsianCalendarKind::Korean)
     }
 
+    type DateCompatibilityError = core::convert::Infallible;
+
+    fn check_date_compatibility(&self, &Self: &Self) -> Result<(), Self::DateCompatibilityError> {
+        Ok(())
+    }
+
     fn calendar_algorithm(&self) -> Option<CalendarAlgorithm> {
         Some(CalendarAlgorithm::Dangi)
     }
@@ -459,7 +480,7 @@ impl Date<KoreanTraditional> {
     ///     .expect("Failed to initialize Date instance.");
     ///
     /// assert_eq!(date.cyclic_year().related_iso, 2025);
-    /// assert_eq!(date.month().as_input(), Month::new(5));
+    /// assert_eq!(date.month().to_input(), Month::new(5));
     /// assert_eq!(date.day_of_month().0, 25);
     /// ```
     pub fn try_new_korean_traditional(
@@ -669,7 +690,7 @@ impl<R: Rules> crate::cal::scaffold::UnstableSealed for EastAsianTraditional<R>
 impl<R: Rules> Calendar for EastAsianTraditional<R> {
     type DateInner = ChineseDateInner<R>;
     type Year = types::CyclicYear;
-    type DifferenceError = core::convert::Infallible;
+    type DateCompatibilityError = R::DateCompatibilityError;
 
     fn from_codes(
         &self,
@@ -740,8 +761,12 @@ impl<R: Rules> Calendar for EastAsianTraditional<R> {
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateDifferenceOptions,
-    ) -> Result<types::DateDuration, Self::DifferenceError> {
-        Ok(date1.0.until(&date2.0, self, options))
+    ) -> types::DateDuration {
+        date1.0.until(&date2.0, self, options)
+    }
+
+    fn check_date_compatibility(&self, other: &Self) -> Result<(), Self::DateCompatibilityError> {
+        self.0.check_date_compatibility(&other.0)
     }
 
     /// Obtain a name for the calendar for debug printing
@@ -808,7 +833,7 @@ impl Date<ChineseTraditional> {
     ///     .expect("Failed to initialize Date instance.");
     ///
     /// assert_eq!(date.cyclic_year().related_iso, 2025);
-    /// assert_eq!(date.month().as_input(), Month::new(5));
+    /// assert_eq!(date.month().to_input(), Month::new(5));
     /// assert_eq!(date.day_of_month().0, 25);
     /// ```
     pub fn try_new_chinese_traditional(
@@ -1146,6 +1171,12 @@ impl<R: Rules> Rules for EastAsianTraditionalYears<R> {
     fn year_containing_rd(&self, rd: RataDie) -> EastAsianTraditionalYear {
         self.1.year_containing_rd(rd)
     }
+
+    type DateCompatibilityError = R::DateCompatibilityError;
+
+    fn check_date_compatibility(&self, other: &Self) -> Result<(), Self::DateCompatibilityError> {
+        self.1.check_date_compatibility(&other.1)
+    }
 }
 
 #[cfg(test)]
@@ -1376,7 +1407,7 @@ mod test {
 
         assert_eq!(chinese.cyclic_year().related_iso, -2636);
         assert_eq!(chinese.month().ordinal, 1);
-        assert_eq!(chinese.month().as_input(), Month::new(1));
+        assert_eq!(chinese.month().to_input(), Month::new(1));
         assert_eq!(chinese.day_of_month().0, 1);
         assert_eq!(chinese.cyclic_year().year, 1);
         assert_eq!(chinese.cyclic_year().related_iso, -2636);
@@ -1569,7 +1600,7 @@ mod test {
             let iso = Date::try_new_iso(case.iso_year, case.iso_month, case.iso_day).unwrap();
             let chinese = iso.to_calendar(ChineseTraditional::new());
             assert_eq!(
-                chinese.month().as_input(),
+                chinese.month().to_input(),
                 case.month,
                 "Month codes did not match for test case: {case:?}"
             );
@@ -1732,7 +1763,7 @@ mod test {
         };
         let date = Date::try_from_fields(fields, options, cal).unwrap();
         assert_eq!(
-            date.month().as_input(),
+            date.month().to_input(),
             Month::new(1),
             "Month was successfully constrained"
         );