From 350a56867e44b5393b043ae7e11c335276f333fa Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishearth@google.com>
Date: Mon, 2 Jun 2025 16:29:22 +0000
Subject: [PATCH] Remove non-ASCII characters from symbols to avoid exposing
 bugs in tooling

See https://chromium-review.googlesource.com/c/chromium/src/+/6611005
calendrical_calculations uses some non-ascii function names that show up
in the symbol table. In the future I may try to remove this patch to see
what else breaks.

Change-Id: I6052192f51a68e25b6b2c91cda4b02d2e0adc14d
---
 third_party/rust/chromium_crates_io/vendor/calendrical_calculations-v0_2/src/hebrew_keviyah.rs                     | 182 +++++++++---------
 1 file changed, 91 insertions(+), 91 deletions(-)

diff --git a/third_party/rust/chromium_crates_io/vendor/calendrical_calculations-v0_2/src/hebrew_keviyah.rs b/third_party/rust/chromium_crates_io/vendor/calendrical_calculations-v0_2/src/hebrew_keviyah.rs
index 9b91a75ecf862..99a5def657dbc 100644
--- a/third_party/rust/chromium_crates_io/vendor/calendrical_calculations-v0_2/src/hebrew_keviyah.rs
+++ b/third_party/rust/chromium_crates_io/vendor/calendrical_calculations-v0_2/src/hebrew_keviyah.rs
@@ -88,7 +88,7 @@ use core::cmp::Ordering;
 // A note on time notation
 //
 // Hebrew timekeeping has some differences from standard timekeeping. A Hebrew day is split into 24
-// hours, each split into 1080 ḥalakim ("parts", abbreviated "ḥal" or "p"). Furthermore, the Hebrew
+// hours, each split into 1080 halakim ("parts", abbreviated "hal" or "p"). Furthermore, the Hebrew
 // day for calendrical purposes canonically starts at 6PM the previous evening, e.g. Hebrew Monday
 // starts on Sunday 6PM. (For non-calendrical observational purposes this varies and is based on
 // the sunset, but that is not too relevant for the algorithms here.)
@@ -98,12 +98,12 @@ use core::cmp::Ordering;
 // to refer to a standard weekday when we particularly wish to avoid ambiguity.
 //
 // Hebrew weeks start on Sunday. A common notation for times of the week looks like 2-5-204, which
-// means "second Hebrew Day of the week, 5h 204 ḥal", which is 5h 204 ḥal after the start of Hebrew
-// Monday (which is 23h:204ḥal on standard Sunday).
+// means "second Hebrew Day of the week, 5h 204 hal", which is 5h 204 hal after the start of Hebrew
+// Monday (which is 23h:204hal on standard Sunday).
 //
-// Some resources will use ḥalakim notation when talking about time during a standard day. This
-// document will use standard `:` notation for this, as used above with 23h:204ḥal being equal to
-// 5h 204ḥal. In other words, if a time is notated using dashes or spaces, it is relative to the
+// Some resources will use halakim notation when talking about time during a standard day. This
+// document will use standard `:` notation for this, as used above with 23h:204hal being equal to
+// 5h 204hal. In other words, if a time is notated using dashes or spaces, it is relative to the
 // hebrew start of day, whereas if it is notated using a colon, it is relative to midnight.
 //
 // Finally, Adjler, the resource we are using, uses both inclusive and exclusive time notation. It
@@ -127,9 +127,9 @@ fn months_preceding_molad(h_year: i32) -> i64 {
     (235 * (i64::from(h_year) - 1) + 1).div_euclid(19)
 }
 
-/// Conveniently create a constant for a ḥalakim (by default in 1-indexed notation). Produces a constant
-/// that tracks the number of ḥalakim since the beginning of the week
-macro_rules! ḥal {
+/// Conveniently create a constant for a halakim (by default in 1-indexed notation). Produces a constant
+/// that tracks the number of halakim since the beginning of the week
+macro_rules! hal {
     ($d:literal-$h:literal-$p:literal) => {{
         const CONSTANT: i32 = (($d - 1) * 24 + $h) * 1080 + $p;
         CONSTANT
@@ -141,34 +141,34 @@ macro_rules! ḥal {
 }
 
 /// The molad Beherad is the first molad, i.e. the molad of the epoch year.
-/// It occurred on Oct 6, 3761 BC, 23h:204ḥal (Jerusalem Time, Julian Calendar)
+/// It occurred on Oct 6, 3761 BC, 23h:204hal (Jerusalem Time, Julian Calendar)
 ///
-/// Which is the second Hebrew day of the week (Hebrew Monday), 5h 204ḥal, 2-5-204.
+/// Which is the second Hebrew day of the week (Hebrew Monday), 5h 204hal, 2-5-204.
 /// ("Beharad" בהרד is just a way of writing 2-5-204, ב-ה-רד using Hebrew numerals)
 ///
-/// This is 31524ḥal after the start of the week (Saturday 6PM)
+/// This is 31524hal after the start of the week (Saturday 6PM)
 ///
 /// From Adjler Appendix A
-const MOLAD_BEHERAD_OFFSET: i32 = ḥal!(2 - 5 - 204);
+const MOLAD_BEHERAD_OFFSET: i32 = hal!(2 - 5 - 204);
 
-/// The amount of time a Hebrew lunation takes (in ḥalakim). This is not exactly the amount of time
+/// The amount of time a Hebrew lunation takes (in halakim). This is not exactly the amount of time
 /// taken by one revolution of the moon (the real world seldom has events that are perfect integer
 /// multiples of 1080ths of an hour), but it is what the Hebrew calendar uses. This does mean that
 /// there will be drift over time with the actual state of the celestial sphere, however that is
 /// irrelevant since the actual state of the celestial sphere is not what is used for the Hebrew
 /// calendar.
 ///
-/// This is 29-12-793 in zero-indexed notation. It is equal to 765433ḥal.
+/// This is 29-12-793 in zero-indexed notation. It is equal to 765433hal.
 /// From Adjler Appendix A
-const HEBREW_LUNATION_TIME: i32 = ḥal!(0-indexed 29-12-793);
+const HEBREW_LUNATION_TIME: i32 = hal!(0-indexed 29-12-793);
 
 /// From Reingold (ch 8.2, in implementation for fixed-from-hebrew)
 const HEBREW_APPROX_YEAR_LENGTH: f64 = 35975351.0 / 98496.0;
 
-/// The number of ḥalakim in a week
+/// The number of halakim in a week
 ///
 /// (This is 181440)
-const ḤALAKIM_IN_WEEK: i64 = 1080 * 24 * 7;
+const hALAKIM_IN_WEEK: i64 = 1080 * 24 * 7;
 
 /// The Hebrew calendar epoch. It did not need to be postponed, so it occurs on Hebrew Monday, Oct 7, 3761 BCE (Julian),
 /// the same as the Molad Beherad.
@@ -191,7 +191,7 @@ pub const HEBREW_MAX_RD: RataDie = RataDie::new(784360204356);
 /// Given a Hebrew Year, returns its molad specified as:
 ///
 /// - The number of weeks since the week of Beharad (Oct 6, 3761 BCE Julian)
-/// - The number of ḥalakim since the start of the week (Hebrew Sunday, starting on Saturday at 18:00)
+/// - The number of halakim since the start of the week (Hebrew Sunday, starting on Saturday at 18:00)
 #[inline]
 fn molad_details(h_year: i32) -> (i64, i32) {
     let months_preceding = months_preceding_molad(h_year);
@@ -201,11 +201,11 @@ fn molad_details(h_year: i32) -> (i64, i32) {
     let molad = MOLAD_BEHERAD_OFFSET as i64 + months_preceding * HEBREW_LUNATION_TIME as i64;
 
     // Split into quotient and remainder
-    let weeks_since_beharad = molad.div_euclid(ḤALAKIM_IN_WEEK);
-    let in_week = molad.rem_euclid(ḤALAKIM_IN_WEEK);
+    let weeks_since_beharad = molad.div_euclid(hALAKIM_IN_WEEK);
+    let in_week = molad.rem_euclid(hALAKIM_IN_WEEK);
 
     let in_week = i32::try_from(in_week);
-    debug_assert!(in_week.is_ok(), "ḤALAKIM_IN_WEEK should fit in an i32");
+    debug_assert!(in_week.is_ok(), "hALAKIM_IN_WEEK should fit in an i32");
 
     (weeks_since_beharad, in_week.unwrap_or(0))
 }
@@ -224,16 +224,16 @@ impl YearInfo {
     /// Compute the YearInfo for a given year
     #[inline]
     pub fn compute_for(h_year: i32) -> Self {
-        let (mut weeks_since_beharad, ḥalakim) = molad_details(h_year);
+        let (mut weeks_since_beharad, halakim) = molad_details(h_year);
 
         let cycle_type = MetonicCycleType::for_h_year(h_year);
 
-        let keviyah = keviyah_for(cycle_type, ḥalakim);
+        let keviyah = keviyah_for(cycle_type, halakim);
 
         // The last six hours of Hebrew Saturday (i.e. after noon on Regular Saturday)
         // get unconditionally postponed to Monday according to the Four Gates table. This
         // puts us in a new week!
-        if ḥalakim >= ḥal!(7 - 18 - 0) {
+        if halakim >= hal!(7 - 18 - 0) {
             weeks_since_beharad += 1;
         }
 
@@ -330,7 +330,7 @@ impl YearInfo {
 /// rely on the leap-keviyot being after the regular ones (and starting with בחה) in is_leap.
 ///
 /// For people unsure if their editor supports bidirectional text,
-/// the first Keviyah (2D3) is Bet (ב), Ḥet (ח), Gimel (ג).
+/// the first Keviyah (2D3) is Bet (ב), het (ח), Gimel (ג).
 ///
 /// (The Hebrew values are used in code for two reasons: firstly, Rust identifiers
 /// can't start with a number, and secondly, sources differ on the Latin alphanumeric notation
@@ -375,11 +375,11 @@ pub enum Keviyah {
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 #[allow(clippy::exhaustive_enums)] // This is intrinsic to the calendar
 pub enum YearType {
-    /// חסרה: both Ḥeshvan and Kislev have 29 days
+    /// חסרה: both heshvan and Kislev have 29 days
     Deficient = -1,
-    /// כסדרה: Ḥeshvan has 29, Kislev has 30
+    /// כסדרה: heshvan has 29, Kislev has 30
     Regular = 0,
-    /// שלמה: both Ḥeshvan and Kislev have 30 days
+    /// שלמה: both heshvan and Kislev have 30 days
     Complete = 1,
 }
 
@@ -389,12 +389,12 @@ impl YearType {
         self as i8
     }
 
-    /// The length of Ḥeshvan
-    fn ḥeshvan_length(self) -> u8 {
+    /// The length of heshvan
+    fn heshvan_length(self) -> u8 {
         if self == Self::Complete {
-            ḤESHVAN_DEFAULT_LEN + 1
+            hESHVAN_DEFAULT_LEN + 1
         } else {
-            ḤESHVAN_DEFAULT_LEN
+            hESHVAN_DEFAULT_LEN
         }
     }
 
@@ -441,7 +441,7 @@ macro_rules! u16_cvt(
 // Month lengths (ref: https://en.wikipedia.org/wiki/Hebrew_calendar#Months)
 const TISHREI_LEN: u8 = 30;
 // except in Complete years
-const ḤESHVAN_DEFAULT_LEN: u8 = 29;
+const hESHVAN_DEFAULT_LEN: u8 = 29;
 // Except in Deficient years
 const KISLEV_DEFAULT_LEN: u8 = 30;
 const TEVET_LEN: u8 = 29;
@@ -461,7 +461,7 @@ const ELUL_LEN: u8 = 29;
 /// Adar, Adar I and Adar II all normalize to 6
 pub const TISHREI: u8 = 1;
 /// Normalized month constant (see [`TISHREI`])
-pub const ḤESHVAN: u8 = 2;
+pub const hESHVAN: u8 = 2;
 /// Normalized month constant (see [`TISHREI`])
 pub const KISLEV: u8 = 3;
 /// Normalized month constant (see [`TISHREI`])
@@ -560,7 +560,7 @@ impl Keviyah {
         debug_assert!(normalized_ordinal_month <= 12 && normalized_ordinal_month > 0);
         match normalized_ordinal_month {
             TISHREI => TISHREI_LEN,
-            ḤESHVAN => self.year_type().ḥeshvan_length(),
+            hESHVAN => self.year_type().heshvan_length(),
             KISLEV => self.year_type().kislev_length(),
             TEVET => TEVET_LEN,
             SHEVAT => SHEVAT_LEN,
@@ -584,7 +584,7 @@ impl Keviyah {
         // convenience constant to keep the additions smallish
         // Number of days before (any) Adar in a regular year
         const BEFORE_ADAR_DEFAULT_LEN: u16 = u16_cvt!(
-            TISHREI_LEN + ḤESHVAN_DEFAULT_LEN + KISLEV_DEFAULT_LEN + TEVET_LEN + SHEVAT_LEN
+            TISHREI_LEN + hESHVAN_DEFAULT_LEN + KISLEV_DEFAULT_LEN + TEVET_LEN + SHEVAT_LEN
         );
 
         let Some(normalized_ordinal_month) = self.normalized_ordinal_month(ordinal_month) else {
@@ -599,12 +599,12 @@ impl Keviyah {
 
         let mut days = match normalized_ordinal_month {
             TISHREI => 0,
-            ḤESHVAN => u16_cvt!(TISHREI_LEN),
-            KISLEV => u16_cvt!(TISHREI_LEN) + u16::from(year_type.ḥeshvan_length()),
+            hESHVAN => u16_cvt!(TISHREI_LEN),
+            KISLEV => u16_cvt!(TISHREI_LEN) + u16::from(year_type.heshvan_length()),
             // Use default lengths after this, we'll apply the correction later
             // (This helps optimize this into a simple jump table)
-            TEVET => u16_cvt!(TISHREI_LEN + ḤESHVAN_DEFAULT_LEN + KISLEV_DEFAULT_LEN),
-            SHEVAT => u16_cvt!(TISHREI_LEN + ḤESHVAN_DEFAULT_LEN + KISLEV_DEFAULT_LEN + TEVET_LEN),
+            TEVET => u16_cvt!(TISHREI_LEN + hESHVAN_DEFAULT_LEN + KISLEV_DEFAULT_LEN),
+            SHEVAT => u16_cvt!(TISHREI_LEN + hESHVAN_DEFAULT_LEN + KISLEV_DEFAULT_LEN + TEVET_LEN),
             ADAR => BEFORE_ADAR_DEFAULT_LEN,
             NISAN => u16_cvt!(BEFORE_ADAR_DEFAULT_LEN + ADAR_LEN),
             IYYAR => u16_cvt!(BEFORE_ADAR_DEFAULT_LEN + ADAR_LEN + NISAN_LEN),
@@ -618,7 +618,7 @@ impl Keviyah {
             _ => u16_cvt!(BEFORE_ADAR_DEFAULT_LEN + ADAR_LEN + NISAN_LEN + IYYAR_LEN + SIVAN_LEN + TAMMUZ_LEN + AV_LEN),
         };
 
-        // If it is after Kislev and Ḥeshvan, we should add the year correction
+        // If it is after Kislev and heshvan, we should add the year correction
         if normalized_ordinal_month > KISLEV {
             // Ensure the casts are fine
             debug_assert!(days > 1 && year_type.length_correction().abs() <= 1);
@@ -672,12 +672,12 @@ impl Keviyah {
     /// Given the hebrew year for this Keviyah, calculate the YearInfo
     #[inline]
     pub fn year_info(self, h_year: i32) -> YearInfo {
-        let (mut weeks_since_beharad, ḥalakim) = molad_details(h_year);
+        let (mut weeks_since_beharad, halakim) = molad_details(h_year);
 
         // The last six hours of Hebrew Saturday (i.e. after noon on Regular Saturday)
         // get unconditionally postponed to Monday according to the Four Gates table. This
         // puts us in a new week!
-        if ḥalakim >= ḥal!(7 - 18 - 0) {
+        if halakim >= hal!(7 - 18 - 0) {
             weeks_since_beharad += 1;
         }
 
@@ -771,7 +771,7 @@ impl MetonicCycleType {
 //
 // Each entry is a range (ending at the next entry), and it corresponds to the equivalent discriminant value of the Keviyah type.
 // Leap and regular years map to different Keviyah values, however regular years all map to the same set of
-// seven values, with differing ḥalakim bounds for each. The first entry in the Four Gates table straddles the end of the previous week
+// seven values, with differing halakim bounds for each. The first entry in the Four Gates table straddles the end of the previous week
 // and the beginning of this one.
 //
 // The regular-year tables only differ by their third and last entries (We may be able to write this as more compact code)
@@ -780,48 +780,48 @@ impl MetonicCycleType {
 // or from Adjler (Appendix 4). Be sure to look at the Adjler table referring the "modern calendar", older tables
 // use slightly different numbers.
 const FOUR_GATES_LMINUSONE: [i32; 7] = [
-    ḥal!(7 - 18 - 0),
-    ḥal!(1 - 9 - 204),
-    ḥal!(2 - 18 - 0),
-    ḥal!(3 - 9 - 204),
-    ḥal!(5 - 9 - 204),
-    ḥal!(5 - 18 - 0),
-    ḥal!(6 - 9 - 204),
+    hal!(7 - 18 - 0),
+    hal!(1 - 9 - 204),
+    hal!(2 - 18 - 0),
+    hal!(3 - 9 - 204),
+    hal!(5 - 9 - 204),
+    hal!(5 - 18 - 0),
+    hal!(6 - 9 - 204),
 ];
 const FOUR_GATES_LPLUSONE: [i32; 7] = [
-    ḥal!(7 - 18 - 0),
-    ḥal!(1 - 9 - 204),
-    ḥal!(2 - 15 - 589),
-    ḥal!(3 - 9 - 204),
-    ḥal!(5 - 9 - 204),
-    ḥal!(5 - 18 - 0),
-    ḥal!(6 - 0 - 408),
+    hal!(7 - 18 - 0),
+    hal!(1 - 9 - 204),
+    hal!(2 - 15 - 589),
+    hal!(3 - 9 - 204),
+    hal!(5 - 9 - 204),
+    hal!(5 - 18 - 0),
+    hal!(6 - 0 - 408),
 ];
 
 const FOUR_GATES_LPLUSMINUSONE: [i32; 7] = [
-    ḥal!(7 - 18 - 0),
-    ḥal!(1 - 9 - 204),
-    ḥal!(2 - 15 - 589),
-    ḥal!(3 - 9 - 204),
-    ḥal!(5 - 9 - 204),
-    ḥal!(5 - 18 - 0),
-    ḥal!(6 - 9 - 204),
+    hal!(7 - 18 - 0),
+    hal!(1 - 9 - 204),
+    hal!(2 - 15 - 589),
+    hal!(3 - 9 - 204),
+    hal!(5 - 9 - 204),
+    hal!(5 - 18 - 0),
+    hal!(6 - 9 - 204),
 ];
 
 const FOUR_GATES_LEAP: [i32; 7] = [
-    ḥal!(7 - 18 - 0),
-    ḥal!(1 - 20 - 491),
-    ḥal!(2 - 18 - 0),
-    ḥal!(3 - 18 - 0),
-    ḥal!(4 - 11 - 695),
-    ḥal!(5 - 18 - 0),
-    ḥal!(6 - 20 - 491),
+    hal!(7 - 18 - 0),
+    hal!(1 - 20 - 491),
+    hal!(2 - 18 - 0),
+    hal!(3 - 18 - 0),
+    hal!(4 - 11 - 695),
+    hal!(5 - 18 - 0),
+    hal!(6 - 20 - 491),
 ];
 
 /// Perform the four gates calculation, giving you the Keviyah for a given year type and
-/// the ḥalakim-since-beginning-of-week of its molad Tishri
+/// the halakim-since-beginning-of-week of its molad Tishri
 #[inline]
-fn keviyah_for(year_type: MetonicCycleType, ḥalakim: i32) -> Keviyah {
+fn keviyah_for(year_type: MetonicCycleType, halakim: i32) -> Keviyah {
     let gate = match year_type {
         MetonicCycleType::LMinusOne => FOUR_GATES_LMINUSONE,
         MetonicCycleType::LPlusOne => FOUR_GATES_LPLUSONE,
@@ -832,17 +832,17 @@ fn keviyah_for(year_type: MetonicCycleType, ḥalakim: i32) -> Keviyah {
     // Calculate the non-leap and leap keviyot for this year
     // This could potentially be made more efficient by just finding
     // the right window on `gate` and transmuting, but this unrolled loop should be fine too.
-    let keviyot = if ḥalakim >= gate[0] || ḥalakim < gate[1] {
+    let keviyot = if halakim >= gate[0] || halakim < gate[1] {
         (Keviyah::בחג, Keviyah::בחה)
-    } else if ḥalakim < gate[2] {
+    } else if halakim < gate[2] {
         (Keviyah::בשה, Keviyah::בשז)
-    } else if ḥalakim < gate[3] {
+    } else if halakim < gate[3] {
         (Keviyah::גכה, Keviyah::גכז)
-    } else if ḥalakim < gate[4] {
+    } else if halakim < gate[4] {
         (Keviyah::הכז, Keviyah::החא)
-    } else if ḥalakim < gate[5] {
+    } else if halakim < gate[5] {
         (Keviyah::השא, Keviyah::השג)
-    } else if ḥalakim < gate[6] {
+    } else if halakim < gate[6] {
         (Keviyah::זחא, Keviyah::זחג)
     } else {
         (Keviyah::זשג, Keviyah::זשה)
@@ -859,14 +859,14 @@ fn keviyah_for(year_type: MetonicCycleType, ḥalakim: i32) -> Keviyah {
     if keviyot.0 as u8 == 0 {
         // The first entry in the gates table straddles the ends of the week
         debug_assert!(
-            ḥalakim >= gate[keviyot.0 as usize] || ḥalakim < gate[(keviyot.0 as usize + 1) % 7],
-            "The table above should produce the right indexed keviyah, instead found {keviyot:?} for time {ḥalakim} (year type {year_type:?})"
+            halakim >= gate[keviyot.0 as usize] || halakim < gate[(keviyot.0 as usize + 1) % 7],
+            "The table above should produce the right indexed keviyah, instead found {keviyot:?} for time {halakim} (year type {year_type:?})"
         );
     } else {
-        // Other entries must properly bound the ḥalakim
+        // Other entries must properly bound the halakim
         debug_assert!(
-            ḥalakim >= gate[keviyot.0 as usize] && ḥalakim < gate[(keviyot.0 as usize + 1) % 7],
-            "The table above should produce the right indexed keviyah, instead found {keviyot:?} for time {ḥalakim} (year type {year_type:?})"
+            halakim >= gate[keviyot.0 as usize] && halakim < gate[(keviyot.0 as usize + 1) % 7],
+            "The table above should produce the right indexed keviyah, instead found {keviyot:?} for time {halakim} (year type {year_type:?})"
         );
     }
 
@@ -885,9 +885,9 @@ mod test {
     #[test]
     fn test_consts() {
         assert_eq!(MOLAD_BEHERAD_OFFSET, 31524);
-        assert_eq!(ḤALAKIM_IN_WEEK, 181440);
+        assert_eq!(hALAKIM_IN_WEEK, 181440);
         // Adjler's printed value for this constant is incorrect (as confirmed by Adjler over email).
-        // Adjler is correct about the value being ḥal!(0-indexed 29-12-793).
+        // Adjler is correct about the value being hal!(0-indexed 29-12-793).
         // which matches the math used in `crate::hebrew::molad()` from Calendrical Calculations.
         //
         // The correct constant is seen in <https://en.wikibooks.org/wiki/Computer_Programming/Hebrew_calendar>
@@ -1042,7 +1042,7 @@ mod test {
     }
     #[test]
     fn test_issue_6262() {
-        // These are years where the molad ḥalakim is *exactly* ḥal!(7 - 18 - 0), we need
+        // These are years where the molad halakim is *exactly* hal!(7 - 18 - 0), we need
         // to ensure the Saturday wraparound logic works correctly
 
         let rds = [
@@ -1060,8 +1060,8 @@ mod test {
             let yi_recomputed = yi.keviyah.year_info(year);
             assert_eq!(yi, yi_recomputed);
             // Double check that these testcases are on the boundary
-            let (_weeks, ḥalakim) = molad_details(year);
-            assert_eq!(ḥalakim, ḥal!(7 - 18 - 0));
+            let (_weeks, halakim) = molad_details(year);
+            assert_eq!(halakim, hal!(7 - 18 - 0));
         }
     }
 }
-- 
2.49.0.1204.g71687c7c1d-goog