From cf29e4feae47ae8f685216f4043a4e726aa1afcd Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Wed, 30 Jun 2021 15:46:35 -0500
Subject: [PATCH 01/17] Teach length::Bag how to switch hour cycles

---
 components/datetime/src/options/length.rs     |   1 -
 .../datetime/src/options/preferences.rs       |   8 +-
 components/datetime/src/pattern/mod.rs        |  79 ++++++++++
 components/datetime/src/provider/gregory.rs   |  10 ++
 components/datetime/src/provider/helpers.rs   |  64 ++++++--
 components/datetime/src/skeleton.rs           | 112 +++++++++++++-
 components/datetime/tests/datetime.rs         |   6 +
 .../tests/lengths_with_preferences.json       | 138 ++++++++++++++++++
 provider/cldr/src/transform/dates/patterns.rs |  73 ++++++++-
 .../json/date_patterns/gregory@1/ar-EG.json   |  12 ++
 .../data/json/date_patterns/gregory@1/ar.json |  12 ++
 .../data/json/date_patterns/gregory@1/bn.json |  12 ++
 .../json/date_patterns/gregory@1/ccp.json     |  12 ++
 .../json/date_patterns/gregory@1/en-001.json  |  12 ++
 .../json/date_patterns/gregory@1/en-ZA.json   |  12 ++
 .../data/json/date_patterns/gregory@1/en.json |  12 ++
 .../json/date_patterns/gregory@1/es-AR.json   |  12 ++
 .../data/json/date_patterns/gregory@1/es.json |  12 ++
 .../data/json/date_patterns/gregory@1/fr.json |  12 ++
 .../data/json/date_patterns/gregory@1/ja.json |  12 ++
 .../data/json/date_patterns/gregory@1/ru.json |  12 ++
 .../json/date_patterns/gregory@1/sr-Cyrl.json |  12 ++
 .../json/date_patterns/gregory@1/sr-Latn.json |  12 ++
 .../data/json/date_patterns/gregory@1/sr.json |  12 ++
 .../data/json/date_patterns/gregory@1/th.json |  12 ++
 .../data/json/date_patterns/gregory@1/tr.json |  12 ++
 .../json/date_patterns/gregory@1/und.json     |  12 ++
 27 files changed, 683 insertions(+), 24 deletions(-)
 create mode 100644 components/datetime/tests/fixtures/tests/lengths_with_preferences.json

diff --git a/components/datetime/src/options/length.rs b/components/datetime/src/options/length.rs
index e6d34c01431..bb56709a206 100644
--- a/components/datetime/src/options/length.rs
+++ b/components/datetime/src/options/length.rs
@@ -82,7 +82,6 @@ use serde::{Deserialize, Serialize};
 pub struct Bag {
     pub date: Option<Date>,
     pub time: Option<Time>,
-    #[cfg_attr(feature = "serde", serde(skip_serializing, skip_deserializing))]
     pub preferences: Option<preferences::Bag>,
 }
 
diff --git a/components/datetime/src/options/preferences.rs b/components/datetime/src/options/preferences.rs
index 23441c6d594..1af9317f1e6 100644
--- a/components/datetime/src/options/preferences.rs
+++ b/components/datetime/src/options/preferences.rs
@@ -51,7 +51,7 @@ pub struct Bag {
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum HourCycle {
-    /// Hour is formatted to be in range 1-24
+    /// Hour is formatted to be in range 1-24 where midnight is 24:00.
     ///
     /// # Examples
     ///
@@ -63,7 +63,7 @@ pub enum HourCycle {
     /// ```
     #[cfg_attr(feature = "serde", serde(rename = "h24"))]
     H24,
-    /// Hour is formatted to be in range 0-23
+    /// Hour is formatted to be in range 0-23 where midnight is 00:00.
     ///
     /// # Examples
     ///
@@ -75,7 +75,7 @@ pub enum HourCycle {
     /// ```
     #[cfg_attr(feature = "serde", serde(rename = "h23"))]
     H23,
-    /// Hour is formatted to be in range 1-12
+    /// Hour is formatted to be in range 1-12 where midnight is 12:00.
     ///
     /// # Examples
     ///
@@ -87,7 +87,7 @@ pub enum HourCycle {
     /// ```
     #[cfg_attr(feature = "serde", serde(rename = "h12"))]
     H12,
-    /// Hour is formatted to be in range 0-11
+    /// Hour is formatted to be in range 0-11 where midnight is 00:00.
     ///
     /// # Examples
     ///
diff --git a/components/datetime/src/pattern/mod.rs b/components/datetime/src/pattern/mod.rs
index 4c979c5daa1..ac832514bce 100644
--- a/components/datetime/src/pattern/mod.rs
+++ b/components/datetime/src/pattern/mod.rs
@@ -6,6 +6,8 @@ mod error;
 mod parser;
 
 use crate::fields::{self, Field, FieldLength, FieldSymbol};
+use crate::provider;
+use crate::skeleton;
 pub use error::Error;
 use parser::Parser;
 use std::{convert::TryFrom, fmt};
@@ -99,6 +101,10 @@ impl Pattern {
         &self.items
     }
 
+    pub fn items_mut(&mut self) -> &mut [PatternItem] {
+        &mut self.items
+    }
+
     pub fn from_bytes(input: &str) -> Result<Self, Error> {
         Parser::new(input).parse().map(Self::from)
     }
@@ -281,3 +287,76 @@ impl Serialize for Pattern {
         }
     }
 }
+
+/// Used to represent either H11/H12, or H23/H24. Skeletons only store these
+/// hour cycles as H12 or H24.
+pub enum FlexibleHourCycle {
+    /// Can either be fields::Hour::H11 or fields::Hour::H12
+    H11H12,
+    /// Can either be fields::Hour::H23 or fields::Hour::H24
+    H23H24,
+}
+
+impl FlexibleHourCycle {
+    fn matches(&self, hour: &fields::Hour) -> bool {
+        match self {
+            FlexibleHourCycle::H11H12 => match hour {
+                fields::Hour::H11 | fields::Hour::H12 => true,
+                fields::Hour::H23 | fields::Hour::H24 => false,
+            },
+            FlexibleHourCycle::H23H24 => match hour {
+                fields::Hour::H11 | fields::Hour::H12 => false,
+                fields::Hour::H23 | fields::Hour::H24 => true,
+            },
+        }
+    }
+
+    /// Skeletons only use h12 and h24.
+    fn to_skeleton_field_symbol(&self) -> fields::Hour {
+        match self {
+            FlexibleHourCycle::H11H12 => fields::Hour::H12,
+            FlexibleHourCycle::H23H24 => fields::Hour::H24,
+        }
+    }
+}
+
+/// Invoke the pattern matching machinery to transform the hour cycle of a pattern. This provides
+/// a safe mapping from a h11/h12 to h23/h24
+pub fn apply_flexible_hour_cycle(
+    datetime: &provider::gregory::patterns::DateTimeFormatsV1,
+    pattern_str: &str,
+    flexible_hour_cycle: FlexibleHourCycle,
+) -> Result<Option<String>, Error> {
+    let mut pattern = Pattern::from_bytes(pattern_str)?;
+
+    for item in pattern.items_mut() {
+        if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
+            if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
+                if flexible_hour_cycle.matches(pattern_hour) {
+                    // The preference hour cycle matches the pattern, bail out early and
+                    // return the current pattern.
+                    return Ok(Some(pattern_str.into()));
+                } else {
+                    // Mutate the pattern with the new symbol, so that it can be matched against.
+                    *symbol =
+                        fields::FieldSymbol::Hour(flexible_hour_cycle.to_skeleton_field_symbol());
+                    break;
+                }
+            }
+        }
+    }
+
+    let skeleton = skeleton::Skeleton::from(&pattern);
+
+    Ok(
+        match skeleton::create_best_pattern_for_fields(
+            &datetime.skeletons,
+            &datetime.length_patterns,
+            &skeleton.as_slice(),
+        ) {
+            skeleton::BestSkeleton::AllFieldsMatch(pattern)
+            | skeleton::BestSkeleton::MissingOrExtraFields(pattern) => Some(format!("{}", pattern)),
+            skeleton::BestSkeleton::NoMatch => None,
+        },
+    )
+}
diff --git a/components/datetime/src/provider/gregory.rs b/components/datetime/src/provider/gregory.rs
index f70cf0023a8..56f4821efcc 100644
--- a/components/datetime/src/provider/gregory.rs
+++ b/components/datetime/src/provider/gregory.rs
@@ -31,8 +31,18 @@ icu_provider::impl_data_marker_no_lifetime!(
 pub struct DatePatternsV1 {
     pub date: patterns::LengthPatternsV1,
 
+    /// The time patterns are used if no hour cycle preference is set. These patterns also represent
+    /// the default hour cycle preference for the locale given the length.
     pub time: patterns::LengthPatternsV1,
 
+    /// Patterns for the locale that can be used in the case of a preference for h11 or h12
+    /// hour cycles.
+    pub time_h11_h12: patterns::LengthPatternsV1,
+
+    /// Patterns for the locale that can be used in the case of a preference for h23 or h24
+    /// hour cycles.
+    pub time_h23_h24: patterns::LengthPatternsV1,
+
     pub datetime: patterns::DateTimeFormatsV1,
 }
 
diff --git a/components/datetime/src/provider/helpers.rs b/components/datetime/src/provider/helpers.rs
index b1e72938d37..ef7b922531f 100644
--- a/components/datetime/src/provider/helpers.rs
+++ b/components/datetime/src/provider/helpers.rs
@@ -5,8 +5,8 @@
 use crate::date;
 use crate::error::DateTimeFormatError;
 use crate::fields;
-use crate::options::{components, length, DateTimeFormatOptions};
-use crate::pattern::Pattern;
+use crate::options::{components, length, preferences, DateTimeFormatOptions};
+use crate::pattern::{Pattern, PatternItem};
 use crate::provider;
 use crate::skeleton;
 use std::borrow::Cow;
@@ -21,7 +21,11 @@ pub trait DateTimePatterns {
     ) -> Result<Option<Pattern>>;
     fn get_pattern_for_length_bag(&self, length: &length::Bag) -> Result<Option<Pattern>>;
     fn get_pattern_for_date_length(&self, length: length::Date) -> Result<Pattern>;
-    fn get_pattern_for_time_length(&self, length: length::Time) -> Result<Pattern>;
+    fn get_pattern_for_time_length(
+        &self,
+        length: length::Time,
+        preferences: &Option<preferences::Bag>,
+    ) -> Result<Pattern>;
     fn get_pattern_for_datetime_length(
         &self,
         length: length::Date,
@@ -82,10 +86,12 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
     fn get_pattern_for_length_bag(&self, length: &length::Bag) -> Result<Option<Pattern>> {
         match (length.date, length.time) {
             (None, None) => Ok(None),
-            (None, Some(time_length)) => self.get_pattern_for_time_length(time_length).map(Some),
+            (None, Some(time_length)) => self
+                .get_pattern_for_time_length(time_length, &length.preferences)
+                .map(Some),
             (Some(date_length), None) => self.get_pattern_for_date_length(date_length).map(Some),
             (Some(date_length), Some(time_length)) => {
-                let time = self.get_pattern_for_time_length(time_length)?;
+                let time = self.get_pattern_for_time_length(time_length, &length.preferences)?;
                 let date = self.get_pattern_for_date_length(date_length)?;
 
                 self.get_pattern_for_datetime_length(date_length, date, time)
@@ -121,15 +127,45 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
         Ok(Pattern::from_bytes_combination(s, date, time)?)
     }
 
-    fn get_pattern_for_time_length(&self, length: length::Time) -> Result<Pattern> {
-        let time = &self.time;
-        let s = match length {
-            length::Time::Full => &time.full,
-            length::Time::Long => &time.long,
-            length::Time::Medium => &time.medium,
-            length::Time::Short => &time.short,
-        };
-        Ok(Pattern::from_bytes(s)?)
+    /// Look up the proper pre-computed pattern for a given length. If a preference for an hour
+    /// cycle is set, it will look look up a pattern in the time_h11_12 or time_h23_h24 provider
+    /// data, and then manually modify the symbol in the pattern if needed.
+    fn get_pattern_for_time_length(
+        &self,
+        length: length::Time,
+        preferences: &Option<preferences::Bag>,
+    ) -> Result<Pattern> {
+        // Apply the hour cycle preference if it exists.
+        if let Some(preferences::Bag {
+            hour_cycle: Some(hour_cycle_pref),
+        }) = preferences
+        {
+            let time = match hour_cycle_pref {
+                preferences::HourCycle::H11 | preferences::HourCycle::H12 => &self.time_h11_h12,
+                preferences::HourCycle::H23 | preferences::HourCycle::H24 => &self.time_h23_h24,
+            };
+            let mut pattern = Pattern::from_bytes(match length {
+                length::Time::Full => &time.full,
+                length::Time::Long => &time.long,
+                length::Time::Medium => &time.medium,
+                length::Time::Short => &time.short,
+            })?;
+            for item in pattern.items_mut() {
+                if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
+                    if let fields::FieldSymbol::Hour(_) = symbol {
+                        *symbol = fields::FieldSymbol::Hour(hour_cycle_pref.field());
+                    }
+                }
+            }
+            return Ok(pattern);
+        }
+
+        Ok(Pattern::from_bytes(match length {
+            length::Time::Full => &self.time.full,
+            length::Time::Long => &self.time.long,
+            length::Time::Medium => &self.time.medium,
+            length::Time::Short => &self.time.short,
+        })?)
     }
 }
 
diff --git a/components/datetime/src/skeleton.rs b/components/datetime/src/skeleton.rs
index cf8d9f424f8..3f6bc73810f 100644
--- a/components/datetime/src/skeleton.rs
+++ b/components/datetime/src/skeleton.rs
@@ -11,7 +11,7 @@ use thiserror::Error;
 use crate::{
     fields::{self, Field, FieldLength, FieldSymbol},
     options::length,
-    pattern::Pattern,
+    pattern::{Pattern, PatternItem},
     provider::gregory::patterns::{LengthPatternsV1, PatternV1, SkeletonV1, SkeletonsV1},
 };
 
@@ -48,6 +48,11 @@ impl Skeleton {
     fn fields_len(&self) -> usize {
         self.0.len()
     }
+
+    /// Return the underlying fields as a slice.
+    pub fn as_slice(&self) -> &[fields::Field] {
+        self.0.as_slice()
+    }
 }
 
 /// This is an implementation of the serde deserialization visitor pattern.
@@ -195,6 +200,62 @@ impl TryFrom<&str> for Skeleton {
     }
 }
 
+/// Convert a Pattern into a Skeleton. This will remove all of the string literals, and sort
+/// the fields into the canonical sort order. Not all fields are supported by Skeletons, so map
+/// fields into skeleton-appropriate ones. For instance, in the "ja" locale the pattern "aK:mm"
+/// gets transformed into the skeleton "hmm".
+impl From<&Pattern> for Skeleton {
+    fn from(pattern: &Pattern) -> Self {
+        let mut fields: SmallVec<[fields::Field; 5]> = SmallVec::new();
+        for item in pattern.items() {
+            if let PatternItem::Field(field) = item {
+                let mut field = *field;
+
+                // Skeletons only have a subset of available fields, these are then mapped to more
+                // specific fields for the patterns they expand to.
+                field.symbol = match field.symbol {
+                    FieldSymbol::Year(year) => FieldSymbol::Year(year),
+                    // Remove the stand-alone designation. This will be provided by the pattern.
+                    FieldSymbol::Month(fields::Month::Format)
+                    | FieldSymbol::Month(fields::Month::StandAlone) => {
+                        FieldSymbol::Month(fields::Month::Format)
+                    }
+                    FieldSymbol::Day(day) => FieldSymbol::Day(day),
+                    FieldSymbol::Weekday(_) => FieldSymbol::Weekday(fields::Weekday::Format),
+
+                    // Only flexible day periods are used in skeletons, ignore all others.
+                    FieldSymbol::DayPeriod(fields::DayPeriod::AmPm)
+                    | FieldSymbol::DayPeriod(fields::DayPeriod::NoonMidnight) => continue,
+                    // TODO(#487) - Flexible day periods should be included here.
+                    // FieldSymbol::DayPeriod(fields::DayPeriod::Flexible) => {
+                    //     FieldSymbol::DayPeriod(fields::DayPeriod::Flexible)
+                    // }
+
+                    // Only the H12 and H24 symbols are used in skeletons, while the patterns may
+                    // contain H11 or H23 depending on the localization.
+                    FieldSymbol::Hour(fields::Hour::H11) | FieldSymbol::Hour(fields::Hour::H12) => {
+                        FieldSymbol::Hour(fields::Hour::H12)
+                    }
+                    FieldSymbol::Hour(fields::Hour::H23) | FieldSymbol::Hour(fields::Hour::H24) => {
+                        FieldSymbol::Hour(fields::Hour::H24)
+                    }
+
+                    // Pass through all of the following preferences unchanged.
+                    FieldSymbol::Minute => FieldSymbol::Minute,
+                    FieldSymbol::Second(second) => FieldSymbol::Second(second),
+                    FieldSymbol::TimeZone(time_zone) => FieldSymbol::TimeZone(time_zone),
+                };
+
+                // Only insert if it's a unique field.
+                if let Err(pos) = fields.binary_search(&field) {
+                    fields.insert(pos, field)
+                }
+            }
+        }
+        Self(fields)
+    }
+}
+
 /// Represents a specific pattern that is available for a given locale.
 /// A [`Skeleton`] is used to match against to find the best pattern.
 #[derive(Debug, PartialEq, Clone)]
@@ -364,9 +425,15 @@ pub fn create_best_pattern_for_fields<'a>(
         // TODO(#583) - TimeZones
         // TODO(#486) - Eras,
         // ... etc.
-        unimplemented!(
-            "There are no \"other\" fields supported, these need to be appended to the pattern. {:?}", other
-        );
+
+        // TODO(#583) - Reviewer: this is commented out because TimeZone support is required
+        // here in order to generate length::Bag patterns correctly. For now I've commented out this
+        // line so that everything works for length::Bag with a preference, although it may lack
+        // a time zone.
+
+        // unimplemented!(
+        //     "There are no \"other\" fields supported, these need to be appended to the pattern. {:?}", other
+        // );
     }
 
     if date.is_empty() || time.is_empty() {
@@ -981,4 +1048,41 @@ mod test {
             "invalid value: field item out of order or duplicate: Field { symbol: Day(DayOfMonth), length: One }, expected ordered field symbols representing a skeleton"
         );
     }
+
+    fn assert_pattern_to_skeleton(pattern: &str, skeleton: &str, message: &str) {
+        assert_eq!(
+            serde_json::to_string(skeleton).unwrap(),
+            serde_json::to_string(&Skeleton::from(&Pattern::from_bytes(pattern).unwrap())).unwrap(),
+            "{}",
+            message
+        );
+    }
+
+    #[test]
+    fn test_pattern_to_skeleton() {
+        assert_pattern_to_skeleton("H:mm:ss v", "Hmmssv", "Test a complicated time pattern");
+
+        assert_pattern_to_skeleton("K:mm", "hmm", "H11 maps to H12");
+        assert_pattern_to_skeleton("k:mm", "Hmm", "H23 maps to H24");
+
+        assert_pattern_to_skeleton("ha mm", "hmm", "Day periods get removed");
+        assert_pattern_to_skeleton("h 'at' b mm", "hmm", "Day periods get removed");
+
+        assert_pattern_to_skeleton("y", "y", "The year is passed through");
+        assert_pattern_to_skeleton("Y", "Y", "The year is passed through");
+
+        assert_pattern_to_skeleton("LLL", "MMM", "Remove standalone months.");
+
+        assert_pattern_to_skeleton("s", "s", "Seconds pass through");
+        assert_pattern_to_skeleton("S", "S", "Seconds pass through");
+        assert_pattern_to_skeleton("A", "A", "Seconds pass through");
+
+        assert_pattern_to_skeleton("z", "z", "Timezones get passed through");
+        assert_pattern_to_skeleton("Z", "Z", "Timezones get passed through");
+        assert_pattern_to_skeleton("O", "O", "Timezones get passed through");
+        assert_pattern_to_skeleton("v", "v", "Timezones get passed through");
+        assert_pattern_to_skeleton("V", "V", "Timezones get passed through");
+        assert_pattern_to_skeleton("X", "X", "Timezones get passed through");
+        assert_pattern_to_skeleton("x", "x", "Timezones get passed through");
+    }
 }
diff --git a/components/datetime/tests/datetime.rs b/components/datetime/tests/datetime.rs
index 26e8937ed1c..1b5978c279c 100644
--- a/components/datetime/tests/datetime.rs
+++ b/components/datetime/tests/datetime.rs
@@ -302,6 +302,12 @@ fn test_length_fixtures() {
     );
 }
 
+#[test]
+fn test_lengths_with_preferences() {
+    // components/datetime/tests/fixtures/tests/lengths_with_preferences.json
+    test_fixture("lengths_with_preferences");
+}
+
 /// Tests component::Bag configurations that have exact matches to CLDR skeletons.
 #[test]
 fn test_components_exact_matches() {
diff --git a/components/datetime/tests/fixtures/tests/lengths_with_preferences.json b/components/datetime/tests/fixtures/tests/lengths_with_preferences.json
new file mode 100644
index 00000000000..6c8afeb4bb9
--- /dev/null
+++ b/components/datetime/tests/fixtures/tests/lengths_with_preferences.json
@@ -0,0 +1,138 @@
+[
+  {
+      "description": "Hour cycle preference h12",
+      "input": {
+          "locale": "en",
+          "value": "2020-02-20T00:12:00.000",
+          "options": {
+              "length": {
+                  "time": "medium",
+                  "date": "medium",
+                  "preferences": { "hourCycle": "h12" }
+              }
+          }
+      },
+      "output": {
+          "value": "Feb 20, 2020, 12:12:00 AM"
+      }
+  },
+  {
+      "description": "Hour cycle preference h24",
+      "input": {
+          "locale": "en",
+          "value": "2020-02-20T00:12:00.000",
+          "options": {
+              "length": {
+                  "time": "medium",
+                  "date": "medium",
+                  "preferences": { "hourCycle": "h24" }
+              }
+          }
+      },
+      "output": {
+          "value": "Feb 20, 2020, 24:12:00"
+      }
+  },
+  {
+      "description": "Hour cycle preference h11",
+      "input": {
+          "locale": "en",
+          "value": "2020-02-20T00:12:00.000",
+          "options": {
+              "length": {
+                  "time": "medium",
+                  "date": "medium",
+                  "preferences": { "hourCycle": "h11" }
+              }
+          }
+      },
+      "output": {
+          "value": "Feb 20, 2020, 0:12:00 AM"
+      }
+  },
+  {
+      "description": "Hour cycle preference h23",
+      "input": {
+          "locale": "en",
+          "value": "2020-02-20T00:12:00.000",
+          "options": {
+              "length": {
+                  "time": "medium",
+                  "date": "medium",
+                  "preferences": { "hourCycle": "h23" }
+              }
+          }
+      },
+      "output": {
+          "value": "Feb 20, 2020, 00:12:00"
+      }
+  },
+  {
+    "description": "Japan hour cycles use h11",
+    "input": {
+        "locale": "ja",
+        "value": "2020-02-20T00:12:00.000",
+        "options": {
+            "length": {
+                "time": "medium",
+                "date": "full",
+                "preferences": { "hourCycle": "h11" }
+            }
+        }
+    },
+    "output": {
+        "value": "2020年2月20日木曜日 午前0:12:00"
+    }
+  },
+  {
+    "description": "Japan hour cycles use h12",
+    "input": {
+        "locale": "ja",
+        "value": "2020-02-20T00:12:00.000",
+        "options": {
+            "length": {
+                "time": "medium",
+                "date": "full",
+                "preferences": { "hourCycle": "h12" }
+            }
+        }
+    },
+    "output": {
+        "value": "2020年2月20日木曜日 午前12:12:00"
+    }
+  },
+  {
+    "description": "Japan hour cycles can use h24",
+    "input": {
+        "locale": "ja",
+        "value": "2020-02-20T00:12:00.000",
+        "options": {
+            "length": {
+                "time": "medium",
+                "date": "full",
+                "preferences": { "hourCycle": "h24" }
+            }
+        }
+    },
+    "output": {
+        "value": "2020年2月20日木曜日 24:12:00"
+    }
+ },
+ {
+    "description": "Japan hour cycles prefer h23",
+    "input": {
+        "locale": "ja",
+        "value": "2020-02-20T00:12:00.000",
+        "options": {
+            "length": {
+                "time": "medium",
+                "date": "full",
+                "preferences": { "hourCycle": "h23" }
+            }
+        }
+    },
+    "output": {
+        "value": "2020年2月20日木曜日 0:12:00"
+    }
+  }
+]
diff --git a/provider/cldr/src/transform/dates/patterns.rs b/provider/cldr/src/transform/dates/patterns.rs
index 6ebdad6ab93..db6913e422c 100644
--- a/provider/cldr/src/transform/dates/patterns.rs
+++ b/provider/cldr/src/transform/dates/patterns.rs
@@ -7,7 +7,7 @@ use crate::cldr_langid::CldrLangID;
 use crate::error::Error;
 use crate::reader::{get_subdirectories, open_reader};
 use crate::CldrPaths;
-use icu_datetime::{provider::*, skeleton::SkeletonError};
+use icu_datetime::{pattern, provider::*, skeleton::SkeletonError};
 use icu_provider::iter::{IterableDataProviderCore, KeyedDataProvider};
 use icu_provider::prelude::*;
 use std::borrow::Cow;
@@ -182,9 +182,80 @@ impl From<&cldr_json::DateTimeFormats> for gregory::patterns::DateTimeFormatsV1
 
 impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
     fn from(other: &cldr_json::Dates) -> Self {
+        let date_time_formats_v1 =
+            gregory::patterns::DateTimeFormatsV1::from(&other.calendars.gregorian.datetime_formats);
+
         Self {
             date: (&other.calendars.gregorian.date_formats).into(),
             time: (&other.calendars.gregorian.time_formats).into(),
+            time_h11_h12: gregory::patterns::LengthPatternsV1 {
+                full: pattern::apply_flexible_hour_cycle(
+                    &date_time_formats_v1,
+                    &other.calendars.gregorian.time_formats.full.get_pattern(),
+                    pattern::FlexibleHourCycle::H11H12,
+                )
+                .unwrap()
+                .unwrap()
+                .into(),
+                long: pattern::apply_flexible_hour_cycle(
+                    &date_time_formats_v1,
+                    &other.calendars.gregorian.time_formats.long.get_pattern(),
+                    pattern::FlexibleHourCycle::H11H12,
+                )
+                .unwrap()
+                .unwrap()
+                .into(),
+                medium: pattern::apply_flexible_hour_cycle(
+                    &date_time_formats_v1,
+                    &other.calendars.gregorian.time_formats.medium.get_pattern(),
+                    pattern::FlexibleHourCycle::H11H12,
+                )
+                .unwrap()
+                .unwrap()
+                .into(),
+                short: pattern::apply_flexible_hour_cycle(
+                    &date_time_formats_v1,
+                    &other.calendars.gregorian.time_formats.short.get_pattern(),
+                    pattern::FlexibleHourCycle::H11H12,
+                )
+                .unwrap()
+                .unwrap()
+                .into(),
+            },
+            time_h23_h24: gregory::patterns::LengthPatternsV1 {
+                full: pattern::apply_flexible_hour_cycle(
+                    &date_time_formats_v1,
+                    &other.calendars.gregorian.time_formats.full.get_pattern(),
+                    pattern::FlexibleHourCycle::H23H24,
+                )
+                .unwrap()
+                .unwrap()
+                .into(),
+                long: pattern::apply_flexible_hour_cycle(
+                    &date_time_formats_v1,
+                    &other.calendars.gregorian.time_formats.long.get_pattern(),
+                    pattern::FlexibleHourCycle::H23H24,
+                )
+                .unwrap()
+                .unwrap()
+                .into(),
+                medium: pattern::apply_flexible_hour_cycle(
+                    &date_time_formats_v1,
+                    &other.calendars.gregorian.time_formats.medium.get_pattern(),
+                    pattern::FlexibleHourCycle::H23H24,
+                )
+                .unwrap()
+                .unwrap()
+                .into(),
+                short: pattern::apply_flexible_hour_cycle(
+                    &date_time_formats_v1,
+                    &other.calendars.gregorian.time_formats.short.get_pattern(),
+                    pattern::FlexibleHourCycle::H23H24,
+                )
+                .unwrap()
+                .unwrap()
+                .into(),
+            },
             datetime: (&other.calendars.gregorian.datetime_formats).into(),
         }
     }
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json b/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
index 2ae1d61f673..b81106f1fb0 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
@@ -11,6 +11,18 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a zzzz",
+    "long": "h:mm:ss a z",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss",
+    "long": "HH:mm:ss",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} في {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ar.json b/provider/testdata/data/json/date_patterns/gregory@1/ar.json
index 2ae1d61f673..b81106f1fb0 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ar.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ar.json
@@ -11,6 +11,18 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a zzzz",
+    "long": "h:mm:ss a z",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss",
+    "long": "HH:mm:ss",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} في {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/bn.json b/provider/testdata/data/json/date_patterns/gregory@1/bn.json
index bf86408aeb5..cf86908c53c 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/bn.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/bn.json
@@ -11,6 +11,18 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a zzzz",
+    "long": "h:mm:ss a z",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss",
+    "long": "HH:mm:ss",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ccp.json b/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
index bf86408aeb5..cf86908c53c 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
@@ -11,6 +11,18 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a zzzz",
+    "long": "h:mm:ss a z",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss",
+    "long": "HH:mm:ss",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en-001.json b/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
index d3307750055..5a9d3d7d942 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
@@ -11,6 +11,18 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a zzzz",
+    "long": "h:mm:ss a z",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss",
+    "long": "HH:mm:ss",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} 'at' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json b/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
index a905a6435eb..66f416f7ae4 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} 'at' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en.json b/provider/testdata/data/json/date_patterns/gregory@1/en.json
index 5c8943b89b5..97d75b124a1 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en.json
@@ -11,6 +11,18 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a zzzz",
+    "long": "h:mm:ss a z",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss",
+    "long": "HH:mm:ss",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} 'at' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json b/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
index a0234723a37..9b6cfbd2fa6 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "hh:mm:ss",
+    "long": "hh:mm:ss",
+    "medium": "hh:mm:ss",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/es.json b/provider/testdata/data/json/date_patterns/gregory@1/es.json
index 50a0357e559..4e1603fd9d1 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/es.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/es.json
@@ -11,6 +11,18 @@
     "medium": "H:mm:ss",
     "short": "H:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "H:mm:ss (zzzz)",
+    "long": "H:mm:ss z",
+    "medium": "H:mm:ss",
+    "short": "H:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/fr.json b/provider/testdata/data/json/date_patterns/gregory@1/fr.json
index 91aecce7c20..231548aab05 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/fr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/fr.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} 'à' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ja.json b/provider/testdata/data/json/date_patterns/gregory@1/ja.json
index 28f5e8d7542..efc4d274f04 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ja.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ja.json
@@ -11,6 +11,18 @@
     "medium": "H:mm:ss",
     "short": "H:mm"
   },
+  "time_h11_h12": {
+    "full": "aK:mm:ss",
+    "long": "aK:mm:ss",
+    "medium": "aK:mm:ss",
+    "short": "aK:mm"
+  },
+  "time_h23_h24": {
+    "full": "H時mm分ss秒 zzzz",
+    "long": "H:mm:ss z",
+    "medium": "H:mm:ss",
+    "short": "H:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ru.json b/provider/testdata/data/json/date_patterns/gregory@1/ru.json
index 7543d5a8a17..3f77516e34c 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ru.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ru.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json b/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
index 7f84d490a6c..9414a9effaf 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json b/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
index 7f84d490a6c..9414a9effaf 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr.json b/provider/testdata/data/json/date_patterns/gregory@1/sr.json
index 7f84d490a6c..9414a9effaf 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/th.json b/provider/testdata/data/json/date_patterns/gregory@1/th.json
index 1fb3e6a036b..af6f1d5bb1e 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/th.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/th.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "H นาฬิกา mm นาที ss วินาที zzzz",
+    "long": "H นาฬิกา mm นาที ss วินาที z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/tr.json b/provider/testdata/data/json/date_patterns/gregory@1/tr.json
index cced46a3ccb..25c2d89f895 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/tr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/tr.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "a h:mm:ss",
+    "long": "a h:mm:ss",
+    "medium": "a h:mm:ss",
+    "short": "a h:mm"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/und.json b/provider/testdata/data/json/date_patterns/gregory@1/und.json
index aa8a8d2349d..bbd4f48bc02 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/und.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/und.json
@@ -11,6 +11,18 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
+    "full": "HH:mm:ss zzzz",
+    "long": "HH:mm:ss z",
+    "medium": "HH:mm:ss",
+    "short": "HH:mm"
+  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",

From 4e891be768979f20386eeae26b5de30c13d85dce Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Thu, 1 Jul 2021 14:32:29 -0500
Subject: [PATCH 02/17] De-duplicate the hour cycle in the length data

---
 components/datetime/src/pattern/mod.rs        |  72 ++++++++++---
 components/datetime/src/provider/gregory.rs   |  12 +--
 components/datetime/src/provider/helpers.rs   |  11 +-
 provider/cldr/src/transform/dates/patterns.rs | 101 ++++++++++--------
 .../json/date_patterns/gregory@1/ar-EG.json   |   9 +-
 .../data/json/date_patterns/gregory@1/ar.json |   9 +-
 .../data/json/date_patterns/gregory@1/bn.json |   9 +-
 .../json/date_patterns/gregory@1/ccp.json     |   9 +-
 .../json/date_patterns/gregory@1/en-001.json  |   9 +-
 .../json/date_patterns/gregory@1/en-ZA.json   |   9 +-
 .../data/json/date_patterns/gregory@1/en.json |   9 +-
 .../json/date_patterns/gregory@1/es-AR.json   |   9 +-
 .../data/json/date_patterns/gregory@1/es.json |   9 +-
 .../data/json/date_patterns/gregory@1/fr.json |   9 +-
 .../data/json/date_patterns/gregory@1/ja.json |   9 +-
 .../data/json/date_patterns/gregory@1/ru.json |   9 +-
 .../json/date_patterns/gregory@1/sr-Cyrl.json |   9 +-
 .../json/date_patterns/gregory@1/sr-Latn.json |   9 +-
 .../data/json/date_patterns/gregory@1/sr.json |   9 +-
 .../data/json/date_patterns/gregory@1/th.json |   9 +-
 .../data/json/date_patterns/gregory@1/tr.json |   9 +-
 .../json/date_patterns/gregory@1/und.json     |   9 +-
 22 files changed, 159 insertions(+), 199 deletions(-)

diff --git a/components/datetime/src/pattern/mod.rs b/components/datetime/src/pattern/mod.rs
index ac832514bce..51da7af2e09 100644
--- a/components/datetime/src/pattern/mod.rs
+++ b/components/datetime/src/pattern/mod.rs
@@ -6,6 +6,7 @@ mod error;
 mod parser;
 
 use crate::fields::{self, Field, FieldLength, FieldSymbol};
+use crate::options::preferences;
 use crate::provider;
 use crate::skeleton;
 pub use error::Error;
@@ -290,6 +291,11 @@ impl Serialize for Pattern {
 
 /// Used to represent either H11/H12, or H23/H24. Skeletons only store these
 /// hour cycles as H12 or H24.
+#[derive(Debug, PartialEq, Clone, Copy)]
+#[cfg_attr(
+    feature = "provider_serde",
+    derive(serde::Serialize, serde::Deserialize)
+)]
 pub enum FlexibleHourCycle {
     /// Can either be fields::Hour::H11 or fields::Hour::H12
     H11H12,
@@ -297,8 +303,15 @@ pub enum FlexibleHourCycle {
     H23H24,
 }
 
+/// Default is required for serialization, arbitrarily pick one.
+impl Default for FlexibleHourCycle {
+    fn default() -> Self {
+        FlexibleHourCycle::H11H12
+    }
+}
+
 impl FlexibleHourCycle {
-    fn matches(&self, hour: &fields::Hour) -> bool {
+    pub fn matches_field(&self, hour: &fields::Hour) -> bool {
         match self {
             FlexibleHourCycle::H11H12 => match hour {
                 fields::Hour::H11 | fields::Hour::H12 => true,
@@ -311,6 +324,19 @@ impl FlexibleHourCycle {
         }
     }
 
+    pub fn matches_preference(&self, hour: &preferences::HourCycle) -> bool {
+        match self {
+            FlexibleHourCycle::H11H12 => match hour {
+                preferences::HourCycle::H11 | preferences::HourCycle::H12 => true,
+                preferences::HourCycle::H23 | preferences::HourCycle::H24 => false,
+            },
+            FlexibleHourCycle::H23H24 => match hour {
+                preferences::HourCycle::H11 | preferences::HourCycle::H12 => false,
+                preferences::HourCycle::H23 | preferences::HourCycle::H24 => true,
+            },
+        }
+    }
+
     /// Skeletons only use h12 and h24.
     fn to_skeleton_field_symbol(&self) -> fields::Hour {
         match self {
@@ -320,22 +346,36 @@ impl FlexibleHourCycle {
     }
 }
 
+pub fn determine_flexible_hour_cycle(pattern: &Pattern) -> Option<FlexibleHourCycle> {
+    for item in pattern.items() {
+        if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
+            if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
+                return Some(match pattern_hour {
+                    fields::Hour::H11 | fields::Hour::H12 => FlexibleHourCycle::H11H12,
+                    fields::Hour::H23 | fields::Hour::H24 => FlexibleHourCycle::H23H24,
+                });
+            }
+        }
+    }
+
+    None
+}
+
 /// Invoke the pattern matching machinery to transform the hour cycle of a pattern. This provides
 /// a safe mapping from a h11/h12 to h23/h24
 pub fn apply_flexible_hour_cycle(
     datetime: &provider::gregory::patterns::DateTimeFormatsV1,
     pattern_str: &str,
+    mut pattern: Pattern,
     flexible_hour_cycle: FlexibleHourCycle,
-) -> Result<Option<String>, Error> {
-    let mut pattern = Pattern::from_bytes(pattern_str)?;
-
+) -> Option<String> {
     for item in pattern.items_mut() {
         if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
             if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
-                if flexible_hour_cycle.matches(pattern_hour) {
+                if flexible_hour_cycle.matches_field(pattern_hour) {
                     // The preference hour cycle matches the pattern, bail out early and
                     // return the current pattern.
-                    return Ok(Some(pattern_str.into()));
+                    return Some(pattern_str.into());
                 } else {
                     // Mutate the pattern with the new symbol, so that it can be matched against.
                     *symbol =
@@ -348,15 +388,13 @@ pub fn apply_flexible_hour_cycle(
 
     let skeleton = skeleton::Skeleton::from(&pattern);
 
-    Ok(
-        match skeleton::create_best_pattern_for_fields(
-            &datetime.skeletons,
-            &datetime.length_patterns,
-            &skeleton.as_slice(),
-        ) {
-            skeleton::BestSkeleton::AllFieldsMatch(pattern)
-            | skeleton::BestSkeleton::MissingOrExtraFields(pattern) => Some(format!("{}", pattern)),
-            skeleton::BestSkeleton::NoMatch => None,
-        },
-    )
+    match skeleton::create_best_pattern_for_fields(
+        &datetime.skeletons,
+        &datetime.length_patterns,
+        &skeleton.as_slice(),
+    ) {
+        skeleton::BestSkeleton::AllFieldsMatch(pattern)
+        | skeleton::BestSkeleton::MissingOrExtraFields(pattern) => Some(format!("{}", pattern)),
+        skeleton::BestSkeleton::NoMatch => None,
+    }
 }
diff --git a/components/datetime/src/provider/gregory.rs b/components/datetime/src/provider/gregory.rs
index 56f4821efcc..84eef936140 100644
--- a/components/datetime/src/provider/gregory.rs
+++ b/components/datetime/src/provider/gregory.rs
@@ -2,6 +2,7 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
+use crate::pattern;
 use std::borrow::Cow;
 
 #[derive(Debug, PartialEq, Clone, Default)]
@@ -35,13 +36,12 @@ pub struct DatePatternsV1 {
     /// the default hour cycle preference for the locale given the length.
     pub time: patterns::LengthPatternsV1,
 
-    /// Patterns for the locale that can be used in the case of a preference for h11 or h12
-    /// hour cycles.
-    pub time_h11_h12: patterns::LengthPatternsV1,
+    /// The flexible hour cycle that is used in the `time`.
+    pub preferred_hour_cycle: pattern::FlexibleHourCycle,
 
-    /// Patterns for the locale that can be used in the case of a preference for h23 or h24
-    /// hour cycles.
-    pub time_h23_h24: patterns::LengthPatternsV1,
+    /// Users can override the hour cycle with a preference. These patterns contain the
+    /// non-preferred hour cycles.
+    pub time_with_alt_hour_cycle: patterns::LengthPatternsV1,
 
     pub datetime: patterns::DateTimeFormatsV1,
 }
diff --git a/components/datetime/src/provider/helpers.rs b/components/datetime/src/provider/helpers.rs
index ef7b922531f..7975c171069 100644
--- a/components/datetime/src/provider/helpers.rs
+++ b/components/datetime/src/provider/helpers.rs
@@ -140,10 +140,15 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
             hour_cycle: Some(hour_cycle_pref),
         }) = preferences
         {
-            let time = match hour_cycle_pref {
-                preferences::HourCycle::H11 | preferences::HourCycle::H12 => &self.time_h11_h12,
-                preferences::HourCycle::H23 | preferences::HourCycle::H24 => &self.time_h23_h24,
+            let time = if self
+                .preferred_hour_cycle
+                .matches_preference(&hour_cycle_pref)
+            {
+                &self.time
+            } else {
+                &self.time_with_alt_hour_cycle
             };
+
             let mut pattern = Pattern::from_bytes(match length {
                 length::Time::Full => &time.full,
                 length::Time::Long => &time.long,
diff --git a/provider/cldr/src/transform/dates/patterns.rs b/provider/cldr/src/transform/dates/patterns.rs
index db6913e422c..d344ea06829 100644
--- a/provider/cldr/src/transform/dates/patterns.rs
+++ b/provider/cldr/src/transform/dates/patterns.rs
@@ -7,6 +7,7 @@ use crate::cldr_langid::CldrLangID;
 use crate::error::Error;
 use crate::reader::{get_subdirectories, open_reader};
 use crate::CldrPaths;
+use icu_datetime::pattern::FlexibleHourCycle;
 use icu_datetime::{pattern, provider::*, skeleton::SkeletonError};
 use icu_provider::iter::{IterableDataProviderCore, KeyedDataProvider};
 use icu_provider::prelude::*;
@@ -185,75 +186,81 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
         let date_time_formats_v1 =
             gregory::patterns::DateTimeFormatsV1::from(&other.calendars.gregorian.datetime_formats);
 
+        let pattern_str_full = other.calendars.gregorian.time_formats.full.get_pattern();
+        let pattern_str_long = other.calendars.gregorian.time_formats.long.get_pattern();
+        let pattern_str_medium = other.calendars.gregorian.time_formats.medium.get_pattern();
+        let pattern_str_short = other.calendars.gregorian.time_formats.short.get_pattern();
+
+        let pattern_full = pattern::Pattern::from_bytes(pattern_str_full).unwrap();
+        let pattern_long = pattern::Pattern::from_bytes(pattern_str_long).unwrap();
+        let pattern_medium = pattern::Pattern::from_bytes(pattern_str_medium).unwrap();
+        let pattern_short = pattern::Pattern::from_bytes(pattern_str_short).unwrap();
+
+        let mut preferred_hour_cycle: Option<FlexibleHourCycle> = None;
+        for hour_cycle in [
+            pattern::determine_flexible_hour_cycle(&pattern_full),
+            pattern::determine_flexible_hour_cycle(&pattern_long),
+            pattern::determine_flexible_hour_cycle(&pattern_medium),
+            pattern::determine_flexible_hour_cycle(&pattern_short),
+        ]
+        .iter()
+        {
+            if let Some(hour_cycle) = hour_cycle {
+                if let Some(preferred_hour_cycle) = preferred_hour_cycle {
+                    assert_eq!(
+                        *hour_cycle, preferred_hour_cycle,
+                        "A locale contained a mix of flexible hour cycle types"
+                    );
+                } else {
+                    preferred_hour_cycle = Some(*hour_cycle);
+                }
+            }
+        }
+
+        let preferred_hour_cycle =
+            preferred_hour_cycle.expect("Could not find a preferred hour cycle.");
+        let alt_hour_cycle = if preferred_hour_cycle == pattern::FlexibleHourCycle::H11H12 {
+            pattern::FlexibleHourCycle::H23H24
+        } else {
+            pattern::FlexibleHourCycle::H11H12
+        };
+
         Self {
             date: (&other.calendars.gregorian.date_formats).into(),
             time: (&other.calendars.gregorian.time_formats).into(),
-            time_h11_h12: gregory::patterns::LengthPatternsV1 {
+            preferred_hour_cycle,
+            time_with_alt_hour_cycle: gregory::patterns::LengthPatternsV1 {
                 full: pattern::apply_flexible_hour_cycle(
                     &date_time_formats_v1,
-                    &other.calendars.gregorian.time_formats.full.get_pattern(),
-                    pattern::FlexibleHourCycle::H11H12,
+                    &pattern_str_full,
+                    pattern_full,
+                    alt_hour_cycle,
                 )
                 .unwrap()
-                .unwrap()
                 .into(),
                 long: pattern::apply_flexible_hour_cycle(
                     &date_time_formats_v1,
-                    &other.calendars.gregorian.time_formats.long.get_pattern(),
-                    pattern::FlexibleHourCycle::H11H12,
+                    &pattern_str_long,
+                    pattern_long,
+                    alt_hour_cycle,
                 )
                 .unwrap()
-                .unwrap()
                 .into(),
                 medium: pattern::apply_flexible_hour_cycle(
                     &date_time_formats_v1,
-                    &other.calendars.gregorian.time_formats.medium.get_pattern(),
-                    pattern::FlexibleHourCycle::H11H12,
+                    &pattern_str_medium,
+                    pattern_medium,
+                    alt_hour_cycle,
                 )
                 .unwrap()
-                .unwrap()
                 .into(),
                 short: pattern::apply_flexible_hour_cycle(
                     &date_time_formats_v1,
-                    &other.calendars.gregorian.time_formats.short.get_pattern(),
-                    pattern::FlexibleHourCycle::H11H12,
+                    &pattern_str_short,
+                    pattern_short,
+                    alt_hour_cycle,
                 )
                 .unwrap()
-                .unwrap()
-                .into(),
-            },
-            time_h23_h24: gregory::patterns::LengthPatternsV1 {
-                full: pattern::apply_flexible_hour_cycle(
-                    &date_time_formats_v1,
-                    &other.calendars.gregorian.time_formats.full.get_pattern(),
-                    pattern::FlexibleHourCycle::H23H24,
-                )
-                .unwrap()
-                .unwrap()
-                .into(),
-                long: pattern::apply_flexible_hour_cycle(
-                    &date_time_formats_v1,
-                    &other.calendars.gregorian.time_formats.long.get_pattern(),
-                    pattern::FlexibleHourCycle::H23H24,
-                )
-                .unwrap()
-                .unwrap()
-                .into(),
-                medium: pattern::apply_flexible_hour_cycle(
-                    &date_time_formats_v1,
-                    &other.calendars.gregorian.time_formats.medium.get_pattern(),
-                    pattern::FlexibleHourCycle::H23H24,
-                )
-                .unwrap()
-                .unwrap()
-                .into(),
-                short: pattern::apply_flexible_hour_cycle(
-                    &date_time_formats_v1,
-                    &other.calendars.gregorian.time_formats.short.get_pattern(),
-                    pattern::FlexibleHourCycle::H23H24,
-                )
-                .unwrap()
-                .unwrap()
                 .into(),
             },
             datetime: (&other.calendars.gregorian.datetime_formats).into(),
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json b/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
index b81106f1fb0..ffc9de68649 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
@@ -11,13 +11,8 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h11_h12": {
-    "full": "h:mm:ss a zzzz",
-    "long": "h:mm:ss a z",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
-  "time_h23_h24": {
+  "preferred_hour_cycle": "H11H12",
+  "time_with_alt_hour_cycle": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ar.json b/provider/testdata/data/json/date_patterns/gregory@1/ar.json
index b81106f1fb0..ffc9de68649 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ar.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ar.json
@@ -11,13 +11,8 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h11_h12": {
-    "full": "h:mm:ss a zzzz",
-    "long": "h:mm:ss a z",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
-  "time_h23_h24": {
+  "preferred_hour_cycle": "H11H12",
+  "time_with_alt_hour_cycle": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/bn.json b/provider/testdata/data/json/date_patterns/gregory@1/bn.json
index cf86908c53c..e7ee6decda5 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/bn.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/bn.json
@@ -11,13 +11,8 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h11_h12": {
-    "full": "h:mm:ss a zzzz",
-    "long": "h:mm:ss a z",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
-  "time_h23_h24": {
+  "preferred_hour_cycle": "H11H12",
+  "time_with_alt_hour_cycle": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ccp.json b/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
index cf86908c53c..e7ee6decda5 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
@@ -11,13 +11,8 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h11_h12": {
-    "full": "h:mm:ss a zzzz",
-    "long": "h:mm:ss a z",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
-  "time_h23_h24": {
+  "preferred_hour_cycle": "H11H12",
+  "time_with_alt_hour_cycle": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en-001.json b/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
index 5a9d3d7d942..5b9d2d957de 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
@@ -11,13 +11,8 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h11_h12": {
-    "full": "h:mm:ss a zzzz",
-    "long": "h:mm:ss a z",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
-  "time_h23_h24": {
+  "preferred_hour_cycle": "H11H12",
+  "time_with_alt_hour_cycle": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json b/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
index 66f416f7ae4..9b3ee5a9ab5 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} 'at' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en.json b/provider/testdata/data/json/date_patterns/gregory@1/en.json
index 97d75b124a1..c06d5fac7a1 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en.json
@@ -11,13 +11,8 @@
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h11_h12": {
-    "full": "h:mm:ss a zzzz",
-    "long": "h:mm:ss a z",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
-  "time_h23_h24": {
+  "preferred_hour_cycle": "H11H12",
+  "time_with_alt_hour_cycle": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json b/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
index 9b6cfbd2fa6..b655a5417dc 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "hh:mm:ss",
     "long": "hh:mm:ss",
     "medium": "hh:mm:ss",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/es.json b/provider/testdata/data/json/date_patterns/gregory@1/es.json
index 4e1603fd9d1..b754f4fc1c9 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/es.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/es.json
@@ -11,18 +11,13 @@
     "medium": "H:mm:ss",
     "short": "H:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "H:mm:ss (zzzz)",
-    "long": "H:mm:ss z",
-    "medium": "H:mm:ss",
-    "short": "H:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/fr.json b/provider/testdata/data/json/date_patterns/gregory@1/fr.json
index 231548aab05..e73bcff4cc4 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/fr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/fr.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} 'à' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ja.json b/provider/testdata/data/json/date_patterns/gregory@1/ja.json
index efc4d274f04..5ec38f0d0df 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ja.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ja.json
@@ -11,18 +11,13 @@
     "medium": "H:mm:ss",
     "short": "H:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "aK:mm:ss",
     "long": "aK:mm:ss",
     "medium": "aK:mm:ss",
     "short": "aK:mm"
   },
-  "time_h23_h24": {
-    "full": "H時mm分ss秒 zzzz",
-    "long": "H:mm:ss z",
-    "medium": "H:mm:ss",
-    "short": "H:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ru.json b/provider/testdata/data/json/date_patterns/gregory@1/ru.json
index 3f77516e34c..92bd3e07de2 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ru.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ru.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json b/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
index 9414a9effaf..8b42e765406 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json b/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
index 9414a9effaf..8b42e765406 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr.json b/provider/testdata/data/json/date_patterns/gregory@1/sr.json
index 9414a9effaf..8b42e765406 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/th.json b/provider/testdata/data/json/date_patterns/gregory@1/th.json
index af6f1d5bb1e..e310dbe77af 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/th.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/th.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "H นาฬิกา mm นาที ss วินาที zzzz",
-    "long": "H นาฬิกา mm นาที ss วินาที z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/tr.json b/provider/testdata/data/json/date_patterns/gregory@1/tr.json
index 25c2d89f895..17f8337ac5f 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/tr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/tr.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "a h:mm:ss",
     "long": "a h:mm:ss",
     "medium": "a h:mm:ss",
     "short": "a h:mm"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/und.json b/provider/testdata/data/json/date_patterns/gregory@1/und.json
index bbd4f48bc02..8125a611e25 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/und.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/und.json
@@ -11,18 +11,13 @@
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
-  "time_h11_h12": {
+  "preferred_hour_cycle": "H23H24",
+  "time_with_alt_hour_cycle": {
     "full": "h:mm:ss a",
     "long": "h:mm:ss a",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "time_h23_h24": {
-    "full": "HH:mm:ss zzzz",
-    "long": "HH:mm:ss z",
-    "medium": "HH:mm:ss",
-    "short": "HH:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",

From d6d0575f93ed3f8927218b9d8cb042121bb9e26b Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Fri, 2 Jul 2021 11:03:47 -0500
Subject: [PATCH 03/17] Rename flexible to coarse, and restructure provider
 data

---
 components/datetime/src/pattern/mod.rs        | 34 ++++++-------
 components/datetime/src/provider/gregory.rs   | 22 +++++----
 components/datetime/src/provider/helpers.rs   | 24 +++++-----
 components/datetime/tests/datetime.rs         | 12 +++--
 provider/cldr/src/transform/dates/patterns.rs | 48 +++++++++++--------
 .../json/date_patterns/gregory@1/ar-EG.json   |  6 +--
 .../data/json/date_patterns/gregory@1/ar.json |  6 +--
 .../data/json/date_patterns/gregory@1/bn.json |  6 +--
 .../json/date_patterns/gregory@1/ccp.json     |  6 +--
 .../json/date_patterns/gregory@1/en-001.json  |  6 +--
 .../json/date_patterns/gregory@1/en-ZA.json   | 14 +++---
 .../data/json/date_patterns/gregory@1/en.json |  6 +--
 .../json/date_patterns/gregory@1/es-AR.json   | 14 +++---
 .../data/json/date_patterns/gregory@1/es.json | 14 +++---
 .../data/json/date_patterns/gregory@1/fr.json | 14 +++---
 .../data/json/date_patterns/gregory@1/ja.json | 14 +++---
 .../data/json/date_patterns/gregory@1/ru.json | 14 +++---
 .../json/date_patterns/gregory@1/sr-Cyrl.json | 14 +++---
 .../json/date_patterns/gregory@1/sr-Latn.json | 14 +++---
 .../data/json/date_patterns/gregory@1/sr.json | 14 +++---
 .../data/json/date_patterns/gregory@1/th.json | 14 +++---
 .../data/json/date_patterns/gregory@1/tr.json | 14 +++---
 .../json/date_patterns/gregory@1/und.json     | 14 +++---
 23 files changed, 180 insertions(+), 164 deletions(-)

diff --git a/components/datetime/src/pattern/mod.rs b/components/datetime/src/pattern/mod.rs
index 51da7af2e09..7163df9b68c 100644
--- a/components/datetime/src/pattern/mod.rs
+++ b/components/datetime/src/pattern/mod.rs
@@ -296,7 +296,7 @@ impl Serialize for Pattern {
     feature = "provider_serde",
     derive(serde::Serialize, serde::Deserialize)
 )]
-pub enum FlexibleHourCycle {
+pub enum CoarseHourCycle {
     /// Can either be fields::Hour::H11 or fields::Hour::H12
     H11H12,
     /// Can either be fields::Hour::H23 or fields::Hour::H24
@@ -304,20 +304,20 @@ pub enum FlexibleHourCycle {
 }
 
 /// Default is required for serialization, arbitrarily pick one.
-impl Default for FlexibleHourCycle {
+impl Default for CoarseHourCycle {
     fn default() -> Self {
-        FlexibleHourCycle::H11H12
+        CoarseHourCycle::H11H12
     }
 }
 
-impl FlexibleHourCycle {
+impl CoarseHourCycle {
     pub fn matches_field(&self, hour: &fields::Hour) -> bool {
         match self {
-            FlexibleHourCycle::H11H12 => match hour {
+            CoarseHourCycle::H11H12 => match hour {
                 fields::Hour::H11 | fields::Hour::H12 => true,
                 fields::Hour::H23 | fields::Hour::H24 => false,
             },
-            FlexibleHourCycle::H23H24 => match hour {
+            CoarseHourCycle::H23H24 => match hour {
                 fields::Hour::H11 | fields::Hour::H12 => false,
                 fields::Hour::H23 | fields::Hour::H24 => true,
             },
@@ -326,11 +326,11 @@ impl FlexibleHourCycle {
 
     pub fn matches_preference(&self, hour: &preferences::HourCycle) -> bool {
         match self {
-            FlexibleHourCycle::H11H12 => match hour {
+            CoarseHourCycle::H11H12 => match hour {
                 preferences::HourCycle::H11 | preferences::HourCycle::H12 => true,
                 preferences::HourCycle::H23 | preferences::HourCycle::H24 => false,
             },
-            FlexibleHourCycle::H23H24 => match hour {
+            CoarseHourCycle::H23H24 => match hour {
                 preferences::HourCycle::H11 | preferences::HourCycle::H12 => false,
                 preferences::HourCycle::H23 | preferences::HourCycle::H24 => true,
             },
@@ -340,19 +340,19 @@ impl FlexibleHourCycle {
     /// Skeletons only use h12 and h24.
     fn to_skeleton_field_symbol(&self) -> fields::Hour {
         match self {
-            FlexibleHourCycle::H11H12 => fields::Hour::H12,
-            FlexibleHourCycle::H23H24 => fields::Hour::H24,
+            CoarseHourCycle::H11H12 => fields::Hour::H12,
+            CoarseHourCycle::H23H24 => fields::Hour::H24,
         }
     }
 }
 
-pub fn determine_flexible_hour_cycle(pattern: &Pattern) -> Option<FlexibleHourCycle> {
+pub fn determine_coarse_hour_cycle(pattern: &Pattern) -> Option<CoarseHourCycle> {
     for item in pattern.items() {
         if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
             if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
                 return Some(match pattern_hour {
-                    fields::Hour::H11 | fields::Hour::H12 => FlexibleHourCycle::H11H12,
-                    fields::Hour::H23 | fields::Hour::H24 => FlexibleHourCycle::H23H24,
+                    fields::Hour::H11 | fields::Hour::H12 => CoarseHourCycle::H11H12,
+                    fields::Hour::H23 | fields::Hour::H24 => CoarseHourCycle::H23H24,
                 });
             }
         }
@@ -363,23 +363,23 @@ pub fn determine_flexible_hour_cycle(pattern: &Pattern) -> Option<FlexibleHourCy
 
 /// Invoke the pattern matching machinery to transform the hour cycle of a pattern. This provides
 /// a safe mapping from a h11/h12 to h23/h24
-pub fn apply_flexible_hour_cycle(
+pub fn apply_coarse_hour_cycle(
     datetime: &provider::gregory::patterns::DateTimeFormatsV1,
     pattern_str: &str,
     mut pattern: Pattern,
-    flexible_hour_cycle: FlexibleHourCycle,
+    coarse_hour_cycle: CoarseHourCycle,
 ) -> Option<String> {
     for item in pattern.items_mut() {
         if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
             if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
-                if flexible_hour_cycle.matches_field(pattern_hour) {
+                if coarse_hour_cycle.matches_field(pattern_hour) {
                     // The preference hour cycle matches the pattern, bail out early and
                     // return the current pattern.
                     return Some(pattern_str.into());
                 } else {
                     // Mutate the pattern with the new symbol, so that it can be matched against.
                     *symbol =
-                        fields::FieldSymbol::Hour(flexible_hour_cycle.to_skeleton_field_symbol());
+                        fields::FieldSymbol::Hour(coarse_hour_cycle.to_skeleton_field_symbol());
                     break;
                 }
             }
diff --git a/components/datetime/src/provider/gregory.rs b/components/datetime/src/provider/gregory.rs
index 84eef936140..d62d59946f9 100644
--- a/components/datetime/src/provider/gregory.rs
+++ b/components/datetime/src/provider/gregory.rs
@@ -32,16 +32,18 @@ icu_provider::impl_data_marker_no_lifetime!(
 pub struct DatePatternsV1 {
     pub date: patterns::LengthPatternsV1,
 
-    /// The time patterns are used if no hour cycle preference is set. These patterns also represent
-    /// the default hour cycle preference for the locale given the length.
-    pub time: patterns::LengthPatternsV1,
-
-    /// The flexible hour cycle that is used in the `time`.
-    pub preferred_hour_cycle: pattern::FlexibleHourCycle,
-
-    /// Users can override the hour cycle with a preference. These patterns contain the
-    /// non-preferred hour cycles.
-    pub time_with_alt_hour_cycle: patterns::LengthPatternsV1,
+    /// These patterns are common uses of time formatting, broken down by the length of the
+    /// pattern. Users can override the hour cycle with a preference, so there are two
+    /// pattern groups stored here. Note that the pattern will contain either h11 or h12.
+    pub time_h11_h12: patterns::LengthPatternsV1,
+
+    /// These patterns are common uses of time formatting, broken down by the length of the
+    /// pattern. Users can override the hour cycle with a preference, so there are two
+    /// pattern groups stored here. Note that the pattern will contain either h23 or h24.
+    pub time_h23_h24: patterns::LengthPatternsV1,
+
+    /// By default a locale will prefer one hour cycle type over another.
+    pub preferred_hour_cycle: pattern::CoarseHourCycle,
 
     pub datetime: patterns::DateTimeFormatsV1,
 }
diff --git a/components/datetime/src/provider/helpers.rs b/components/datetime/src/provider/helpers.rs
index 7975c171069..c69ef8f20d7 100644
--- a/components/datetime/src/provider/helpers.rs
+++ b/components/datetime/src/provider/helpers.rs
@@ -140,15 +140,10 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
             hour_cycle: Some(hour_cycle_pref),
         }) = preferences
         {
-            let time = if self
-                .preferred_hour_cycle
-                .matches_preference(&hour_cycle_pref)
-            {
-                &self.time
-            } else {
-                &self.time_with_alt_hour_cycle
+            let time = match hour_cycle_pref {
+                preferences::HourCycle::H11 | preferences::HourCycle::H12 => &self.time_h11_h12,
+                preferences::HourCycle::H23 | preferences::HourCycle::H24 => &self.time_h23_h24,
             };
-
             let mut pattern = Pattern::from_bytes(match length {
                 length::Time::Full => &time.full,
                 length::Time::Long => &time.long,
@@ -165,11 +160,16 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
             return Ok(pattern);
         }
 
+        let time = match self.preferred_hour_cycle {
+            crate::pattern::CoarseHourCycle::H11H12 => &self.time_h11_h12,
+            crate::pattern::CoarseHourCycle::H23H24 => &self.time_h23_h24,
+        };
+
         Ok(Pattern::from_bytes(match length {
-            length::Time::Full => &self.time.full,
-            length::Time::Long => &self.time.long,
-            length::Time::Medium => &self.time.medium,
-            length::Time::Short => &self.time.short,
+            length::Time::Full => &time.full,
+            length::Time::Long => &time.long,
+            length::Time::Medium => &time.medium,
+            length::Time::Short => &time.short,
         })?)
     }
 }
diff --git a/components/datetime/tests/datetime.rs b/components/datetime/tests/datetime.rs
index 1b5978c279c..c8125e87392 100644
--- a/components/datetime/tests/datetime.rs
+++ b/components/datetime/tests/datetime.rs
@@ -166,9 +166,11 @@ fn test_dayperiod_patterns() {
                 let datetime: MockDateTime = dt_input.parse().unwrap();
                 for DayPeriodExpectation { patterns, expected } in &test_case.expectations {
                     for pattern_input in patterns {
-                        let new_pattern_cow = Cow::Owned(pattern_input.to_string());
+                        let new_pattern_cow1 = Cow::Owned(pattern_input.to_string());
+                        let new_pattern_cow2 = Cow::Owned(pattern_input.to_string());
                         patterns_data.with_mut(move |data| {
-                            data.time.long = new_pattern_cow;
+                            data.time_h11_h12.long = new_pattern_cow1;
+                            data.time_h23_h24.long = new_pattern_cow2;
                         });
                         let provider = MultiKeyStructProvider {
                             symbols: StructProvider {
@@ -248,9 +250,11 @@ fn test_time_zone_patterns() {
 
         for TimeZoneExpectation { patterns, expected } in &test.expectations {
             for pattern_input in patterns {
-                let new_pattern_cow = Cow::Owned(pattern_input.to_string());
+                let new_pattern_cow1 = Cow::Owned(pattern_input.to_string());
+                let new_pattern_cow2 = Cow::Owned(pattern_input.to_string());
                 patterns_data.with_mut(move |data| {
-                    data.time.long = new_pattern_cow;
+                    data.time_h11_h12.long = new_pattern_cow1;
+                    data.time_h23_h24.long = new_pattern_cow2;
                 });
                 let date_provider = MultiKeyStructProvider {
                     symbols: StructProvider {
diff --git a/provider/cldr/src/transform/dates/patterns.rs b/provider/cldr/src/transform/dates/patterns.rs
index d344ea06829..5b2b3597f4b 100644
--- a/provider/cldr/src/transform/dates/patterns.rs
+++ b/provider/cldr/src/transform/dates/patterns.rs
@@ -7,7 +7,7 @@ use crate::cldr_langid::CldrLangID;
 use crate::error::Error;
 use crate::reader::{get_subdirectories, open_reader};
 use crate::CldrPaths;
-use icu_datetime::pattern::FlexibleHourCycle;
+use icu_datetime::pattern::CoarseHourCycle;
 use icu_datetime::{pattern, provider::*, skeleton::SkeletonError};
 use icu_provider::iter::{IterableDataProviderCore, KeyedDataProvider};
 use icu_provider::prelude::*;
@@ -196,12 +196,12 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
         let pattern_medium = pattern::Pattern::from_bytes(pattern_str_medium).unwrap();
         let pattern_short = pattern::Pattern::from_bytes(pattern_str_short).unwrap();
 
-        let mut preferred_hour_cycle: Option<FlexibleHourCycle> = None;
+        let mut preferred_hour_cycle: Option<CoarseHourCycle> = None;
         for hour_cycle in [
-            pattern::determine_flexible_hour_cycle(&pattern_full),
-            pattern::determine_flexible_hour_cycle(&pattern_long),
-            pattern::determine_flexible_hour_cycle(&pattern_medium),
-            pattern::determine_flexible_hour_cycle(&pattern_short),
+            pattern::determine_coarse_hour_cycle(&pattern_full),
+            pattern::determine_coarse_hour_cycle(&pattern_long),
+            pattern::determine_coarse_hour_cycle(&pattern_medium),
+            pattern::determine_coarse_hour_cycle(&pattern_short),
         ]
         .iter()
         {
@@ -219,18 +219,16 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
 
         let preferred_hour_cycle =
             preferred_hour_cycle.expect("Could not find a preferred hour cycle.");
-        let alt_hour_cycle = if preferred_hour_cycle == pattern::FlexibleHourCycle::H11H12 {
-            pattern::FlexibleHourCycle::H23H24
+        let alt_hour_cycle = if preferred_hour_cycle == pattern::CoarseHourCycle::H11H12 {
+            pattern::CoarseHourCycle::H23H24
         } else {
-            pattern::FlexibleHourCycle::H11H12
+            pattern::CoarseHourCycle::H11H12
         };
 
-        Self {
-            date: (&other.calendars.gregorian.date_formats).into(),
-            time: (&other.calendars.gregorian.time_formats).into(),
-            preferred_hour_cycle,
-            time_with_alt_hour_cycle: gregory::patterns::LengthPatternsV1 {
-                full: pattern::apply_flexible_hour_cycle(
+        let (time_h11_h12, time_h23_h24) = {
+            let time = (&other.calendars.gregorian.time_formats).into();
+            let alt_time = gregory::patterns::LengthPatternsV1 {
+                full: pattern::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_full,
                     pattern_full,
@@ -238,7 +236,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                long: pattern::apply_flexible_hour_cycle(
+                long: pattern::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_long,
                     pattern_long,
@@ -246,7 +244,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                medium: pattern::apply_flexible_hour_cycle(
+                medium: pattern::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_medium,
                     pattern_medium,
@@ -254,7 +252,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                short: pattern::apply_flexible_hour_cycle(
+                short: pattern::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_short,
                     pattern_short,
@@ -262,7 +260,19 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-            },
+            };
+
+            match preferred_hour_cycle {
+                CoarseHourCycle::H11H12 => (time, alt_time),
+                CoarseHourCycle::H23H24 => (alt_time, time),
+            }
+        };
+
+        Self {
+            date: (&other.calendars.gregorian.date_formats).into(),
+            time_h11_h12,
+            time_h23_h24,
+            preferred_hour_cycle,
             datetime: (&other.calendars.gregorian.datetime_formats).into(),
         }
     }
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json b/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
index ffc9de68649..3507e7b57a3 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ar-EG.json
@@ -5,19 +5,19 @@
     "medium": "dd‏/MM‏/y",
     "short": "d‏/M‏/y"
   },
-  "time": {
+  "time_h11_h12": {
     "full": "h:mm:ss a zzzz",
     "long": "h:mm:ss a z",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "preferred_hour_cycle": "H11H12",
-  "time_with_alt_hour_cycle": {
+  "time_h23_h24": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "preferred_hour_cycle": "H11H12",
   "datetime": {
     "length_patterns": {
       "full": "{1} في {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ar.json b/provider/testdata/data/json/date_patterns/gregory@1/ar.json
index ffc9de68649..3507e7b57a3 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ar.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ar.json
@@ -5,19 +5,19 @@
     "medium": "dd‏/MM‏/y",
     "short": "d‏/M‏/y"
   },
-  "time": {
+  "time_h11_h12": {
     "full": "h:mm:ss a zzzz",
     "long": "h:mm:ss a z",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "preferred_hour_cycle": "H11H12",
-  "time_with_alt_hour_cycle": {
+  "time_h23_h24": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "preferred_hour_cycle": "H11H12",
   "datetime": {
     "length_patterns": {
       "full": "{1} في {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/bn.json b/provider/testdata/data/json/date_patterns/gregory@1/bn.json
index e7ee6decda5..81c1a660428 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/bn.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/bn.json
@@ -5,19 +5,19 @@
     "medium": "d MMM, y",
     "short": "d/M/yy"
   },
-  "time": {
+  "time_h11_h12": {
     "full": "h:mm:ss a zzzz",
     "long": "h:mm:ss a z",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "preferred_hour_cycle": "H11H12",
-  "time_with_alt_hour_cycle": {
+  "time_h23_h24": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "preferred_hour_cycle": "H11H12",
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ccp.json b/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
index e7ee6decda5..81c1a660428 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ccp.json
@@ -5,19 +5,19 @@
     "medium": "d MMM, y",
     "short": "d/M/yy"
   },
-  "time": {
+  "time_h11_h12": {
     "full": "h:mm:ss a zzzz",
     "long": "h:mm:ss a z",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "preferred_hour_cycle": "H11H12",
-  "time_with_alt_hour_cycle": {
+  "time_h23_h24": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "preferred_hour_cycle": "H11H12",
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en-001.json b/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
index 5b9d2d957de..ab18665d7bf 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en-001.json
@@ -5,19 +5,19 @@
     "medium": "d MMM y",
     "short": "dd/MM/y"
   },
-  "time": {
+  "time_h11_h12": {
     "full": "h:mm:ss a zzzz",
     "long": "h:mm:ss a z",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "preferred_hour_cycle": "H11H12",
-  "time_with_alt_hour_cycle": {
+  "time_h23_h24": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "preferred_hour_cycle": "H11H12",
   "datetime": {
     "length_patterns": {
       "full": "{1} 'at' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json b/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
index 9b3ee5a9ab5..e3039fd526a 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en-ZA.json
@@ -5,19 +5,19 @@
     "medium": "dd MMM y",
     "short": "y/MM/dd"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} 'at' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/en.json b/provider/testdata/data/json/date_patterns/gregory@1/en.json
index c06d5fac7a1..991177dbcf8 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/en.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/en.json
@@ -5,19 +5,19 @@
     "medium": "MMM d, y",
     "short": "M/d/yy"
   },
-  "time": {
+  "time_h11_h12": {
     "full": "h:mm:ss a zzzz",
     "long": "h:mm:ss a z",
     "medium": "h:mm:ss a",
     "short": "h:mm a"
   },
-  "preferred_hour_cycle": "H11H12",
-  "time_with_alt_hour_cycle": {
+  "time_h23_h24": {
     "full": "HH:mm:ss",
     "long": "HH:mm:ss",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
+  "preferred_hour_cycle": "H11H12",
   "datetime": {
     "length_patterns": {
       "full": "{1} 'at' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json b/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
index b655a5417dc..bd33a474cbe 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/es-AR.json
@@ -5,19 +5,19 @@
     "medium": "d MMM y",
     "short": "d/M/yy"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "hh:mm:ss",
+    "long": "hh:mm:ss",
+    "medium": "hh:mm:ss",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "hh:mm:ss",
-    "long": "hh:mm:ss",
-    "medium": "hh:mm:ss",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/es.json b/provider/testdata/data/json/date_patterns/gregory@1/es.json
index b754f4fc1c9..4efed33785c 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/es.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/es.json
@@ -5,19 +5,19 @@
     "medium": "d MMM y",
     "short": "d/M/yy"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "H:mm:ss (zzzz)",
     "long": "H:mm:ss z",
     "medium": "H:mm:ss",
     "short": "H:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/fr.json b/provider/testdata/data/json/date_patterns/gregory@1/fr.json
index e73bcff4cc4..19097b60863 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/fr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/fr.json
@@ -5,19 +5,19 @@
     "medium": "d MMM y",
     "short": "dd/MM/y"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} 'à' {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ja.json b/provider/testdata/data/json/date_patterns/gregory@1/ja.json
index 5ec38f0d0df..1894590f886 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ja.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ja.json
@@ -5,19 +5,19 @@
     "medium": "y/MM/dd",
     "short": "y/MM/dd"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "aK:mm:ss",
+    "long": "aK:mm:ss",
+    "medium": "aK:mm:ss",
+    "short": "aK:mm"
+  },
+  "time_h23_h24": {
     "full": "H時mm分ss秒 zzzz",
     "long": "H:mm:ss z",
     "medium": "H:mm:ss",
     "short": "H:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "aK:mm:ss",
-    "long": "aK:mm:ss",
-    "medium": "aK:mm:ss",
-    "short": "aK:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/ru.json b/provider/testdata/data/json/date_patterns/gregory@1/ru.json
index 92bd3e07de2..1e951c89b89 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/ru.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/ru.json
@@ -5,19 +5,19 @@
     "medium": "d MMM y 'г'.",
     "short": "dd.MM.y"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1}, {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json b/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
index 8b42e765406..f186d6bcfe2 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr-Cyrl.json
@@ -5,19 +5,19 @@
     "medium": "dd.MM.y.",
     "short": "d.M.yy."
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json b/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
index 8b42e765406..f186d6bcfe2 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr-Latn.json
@@ -5,19 +5,19 @@
     "medium": "dd.MM.y.",
     "short": "d.M.yy."
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/sr.json b/provider/testdata/data/json/date_patterns/gregory@1/sr.json
index 8b42e765406..f186d6bcfe2 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/sr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/sr.json
@@ -5,19 +5,19 @@
     "medium": "dd.MM.y.",
     "short": "d.M.yy."
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/th.json b/provider/testdata/data/json/date_patterns/gregory@1/th.json
index e310dbe77af..3659feeb6a2 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/th.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/th.json
@@ -5,19 +5,19 @@
     "medium": "d MMM y",
     "short": "d/M/yy"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "H นาฬิกา mm นาที ss วินาที zzzz",
     "long": "H นาฬิกา mm นาที ss วินาที z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/tr.json b/provider/testdata/data/json/date_patterns/gregory@1/tr.json
index 17f8337ac5f..7e8bb03cd25 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/tr.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/tr.json
@@ -5,19 +5,19 @@
     "medium": "d MMM y",
     "short": "d.MM.y"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "a h:mm:ss",
+    "long": "a h:mm:ss",
+    "medium": "a h:mm:ss",
+    "short": "a h:mm"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "a h:mm:ss",
-    "long": "a h:mm:ss",
-    "medium": "a h:mm:ss",
-    "short": "a h:mm"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",
diff --git a/provider/testdata/data/json/date_patterns/gregory@1/und.json b/provider/testdata/data/json/date_patterns/gregory@1/und.json
index 8125a611e25..1850ef152c6 100644
--- a/provider/testdata/data/json/date_patterns/gregory@1/und.json
+++ b/provider/testdata/data/json/date_patterns/gregory@1/und.json
@@ -5,19 +5,19 @@
     "medium": "y MMM d",
     "short": "y-MM-dd"
   },
-  "time": {
+  "time_h11_h12": {
+    "full": "h:mm:ss a",
+    "long": "h:mm:ss a",
+    "medium": "h:mm:ss a",
+    "short": "h:mm a"
+  },
+  "time_h23_h24": {
     "full": "HH:mm:ss zzzz",
     "long": "HH:mm:ss z",
     "medium": "HH:mm:ss",
     "short": "HH:mm"
   },
   "preferred_hour_cycle": "H23H24",
-  "time_with_alt_hour_cycle": {
-    "full": "h:mm:ss a",
-    "long": "h:mm:ss a",
-    "medium": "h:mm:ss a",
-    "short": "h:mm a"
-  },
   "datetime": {
     "length_patterns": {
       "full": "{1} {0}",

From 4529f360071f480147d1f8a6d073fcf15ae4bafc Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Fri, 2 Jul 2021 11:14:49 -0500
Subject: [PATCH 04/17] Break out hour cycle into its own module

---
 components/datetime/src/pattern/hour_cycle.rs | 101 ++++++++++++++++
 components/datetime/src/pattern/mod.rs        | 114 +-----------------
 components/datetime/src/provider/gregory.rs   |   2 +-
 components/datetime/src/provider/helpers.rs   |   4 +-
 provider/cldr/src/transform/dates/patterns.rs |  24 ++--
 5 files changed, 117 insertions(+), 128 deletions(-)
 create mode 100644 components/datetime/src/pattern/hour_cycle.rs

diff --git a/components/datetime/src/pattern/hour_cycle.rs b/components/datetime/src/pattern/hour_cycle.rs
new file mode 100644
index 00000000000..0b1b855f217
--- /dev/null
+++ b/components/datetime/src/pattern/hour_cycle.rs
@@ -0,0 +1,101 @@
+use crate::fields;
+use crate::pattern::{Pattern, PatternItem};
+use crate::provider;
+use crate::skeleton;
+
+/// Used to represent either H11/H12, or H23/H24. Skeletons only store these
+/// hour cycles as H12 or H24.
+#[derive(Debug, PartialEq, Clone, Copy)]
+#[cfg_attr(
+    feature = "provider_serde",
+    derive(serde::Serialize, serde::Deserialize)
+)]
+pub enum CoarseHourCycle {
+    /// Can either be fields::Hour::H11 or fields::Hour::H12
+    H11H12,
+    /// Can either be fields::Hour::H23 or fields::Hour::H24
+    H23H24,
+}
+
+/// Default is required for serialization, arbitrarily pick one.
+impl Default for CoarseHourCycle {
+    fn default() -> Self {
+        CoarseHourCycle::H11H12
+    }
+}
+
+impl CoarseHourCycle {
+    pub fn matches_field(&self, hour: &fields::Hour) -> bool {
+        match self {
+            CoarseHourCycle::H11H12 => match hour {
+                fields::Hour::H11 | fields::Hour::H12 => true,
+                fields::Hour::H23 | fields::Hour::H24 => false,
+            },
+            CoarseHourCycle::H23H24 => match hour {
+                fields::Hour::H11 | fields::Hour::H12 => false,
+                fields::Hour::H23 | fields::Hour::H24 => true,
+            },
+        }
+    }
+
+    /// Skeletons only use h12 and h24.
+    fn to_skeleton_field_symbol(&self) -> fields::Hour {
+        match self {
+            CoarseHourCycle::H11H12 => fields::Hour::H12,
+            CoarseHourCycle::H23H24 => fields::Hour::H24,
+        }
+    }
+}
+
+pub fn determine_coarse_hour_cycle(pattern: &Pattern) -> Option<CoarseHourCycle> {
+    for item in pattern.items() {
+        if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
+            if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
+                return Some(match pattern_hour {
+                    fields::Hour::H11 | fields::Hour::H12 => CoarseHourCycle::H11H12,
+                    fields::Hour::H23 | fields::Hour::H24 => CoarseHourCycle::H23H24,
+                });
+            }
+        }
+    }
+
+    None
+}
+
+/// Invoke the pattern matching machinery to transform the hour cycle of a pattern. This provides
+/// a safe mapping from a h11/h12 to h23/h24
+pub fn apply_coarse_hour_cycle(
+    datetime: &provider::gregory::patterns::DateTimeFormatsV1,
+    pattern_str: &str,
+    mut pattern: Pattern,
+    coarse_hour_cycle: CoarseHourCycle,
+) -> Option<String> {
+    for item in pattern.items_mut() {
+        if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
+            if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
+                if coarse_hour_cycle.matches_field(pattern_hour) {
+                    // The preference hour cycle matches the pattern, bail out early and
+                    // return the current pattern.
+                    return Some(pattern_str.into());
+                } else {
+                    // Mutate the pattern with the new symbol, so that it can be matched against.
+                    *symbol =
+                        fields::FieldSymbol::Hour(coarse_hour_cycle.to_skeleton_field_symbol());
+                    break;
+                }
+            }
+        }
+    }
+
+    let skeleton = skeleton::Skeleton::from(&pattern);
+
+    match skeleton::create_best_pattern_for_fields(
+        &datetime.skeletons,
+        &datetime.length_patterns,
+        &skeleton.as_slice(),
+    ) {
+        skeleton::BestSkeleton::AllFieldsMatch(pattern)
+        | skeleton::BestSkeleton::MissingOrExtraFields(pattern) => Some(format!("{}", pattern)),
+        skeleton::BestSkeleton::NoMatch => None,
+    }
+}
diff --git a/components/datetime/src/pattern/mod.rs b/components/datetime/src/pattern/mod.rs
index 7163df9b68c..56da9802a22 100644
--- a/components/datetime/src/pattern/mod.rs
+++ b/components/datetime/src/pattern/mod.rs
@@ -3,12 +3,10 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 mod error;
+pub mod hour_cycle;
 mod parser;
 
 use crate::fields::{self, Field, FieldLength, FieldSymbol};
-use crate::options::preferences;
-use crate::provider;
-use crate::skeleton;
 pub use error::Error;
 use parser::Parser;
 use std::{convert::TryFrom, fmt};
@@ -288,113 +286,3 @@ impl Serialize for Pattern {
         }
     }
 }
-
-/// Used to represent either H11/H12, or H23/H24. Skeletons only store these
-/// hour cycles as H12 or H24.
-#[derive(Debug, PartialEq, Clone, Copy)]
-#[cfg_attr(
-    feature = "provider_serde",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-pub enum CoarseHourCycle {
-    /// Can either be fields::Hour::H11 or fields::Hour::H12
-    H11H12,
-    /// Can either be fields::Hour::H23 or fields::Hour::H24
-    H23H24,
-}
-
-/// Default is required for serialization, arbitrarily pick one.
-impl Default for CoarseHourCycle {
-    fn default() -> Self {
-        CoarseHourCycle::H11H12
-    }
-}
-
-impl CoarseHourCycle {
-    pub fn matches_field(&self, hour: &fields::Hour) -> bool {
-        match self {
-            CoarseHourCycle::H11H12 => match hour {
-                fields::Hour::H11 | fields::Hour::H12 => true,
-                fields::Hour::H23 | fields::Hour::H24 => false,
-            },
-            CoarseHourCycle::H23H24 => match hour {
-                fields::Hour::H11 | fields::Hour::H12 => false,
-                fields::Hour::H23 | fields::Hour::H24 => true,
-            },
-        }
-    }
-
-    pub fn matches_preference(&self, hour: &preferences::HourCycle) -> bool {
-        match self {
-            CoarseHourCycle::H11H12 => match hour {
-                preferences::HourCycle::H11 | preferences::HourCycle::H12 => true,
-                preferences::HourCycle::H23 | preferences::HourCycle::H24 => false,
-            },
-            CoarseHourCycle::H23H24 => match hour {
-                preferences::HourCycle::H11 | preferences::HourCycle::H12 => false,
-                preferences::HourCycle::H23 | preferences::HourCycle::H24 => true,
-            },
-        }
-    }
-
-    /// Skeletons only use h12 and h24.
-    fn to_skeleton_field_symbol(&self) -> fields::Hour {
-        match self {
-            CoarseHourCycle::H11H12 => fields::Hour::H12,
-            CoarseHourCycle::H23H24 => fields::Hour::H24,
-        }
-    }
-}
-
-pub fn determine_coarse_hour_cycle(pattern: &Pattern) -> Option<CoarseHourCycle> {
-    for item in pattern.items() {
-        if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
-            if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
-                return Some(match pattern_hour {
-                    fields::Hour::H11 | fields::Hour::H12 => CoarseHourCycle::H11H12,
-                    fields::Hour::H23 | fields::Hour::H24 => CoarseHourCycle::H23H24,
-                });
-            }
-        }
-    }
-
-    None
-}
-
-/// Invoke the pattern matching machinery to transform the hour cycle of a pattern. This provides
-/// a safe mapping from a h11/h12 to h23/h24
-pub fn apply_coarse_hour_cycle(
-    datetime: &provider::gregory::patterns::DateTimeFormatsV1,
-    pattern_str: &str,
-    mut pattern: Pattern,
-    coarse_hour_cycle: CoarseHourCycle,
-) -> Option<String> {
-    for item in pattern.items_mut() {
-        if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
-            if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
-                if coarse_hour_cycle.matches_field(pattern_hour) {
-                    // The preference hour cycle matches the pattern, bail out early and
-                    // return the current pattern.
-                    return Some(pattern_str.into());
-                } else {
-                    // Mutate the pattern with the new symbol, so that it can be matched against.
-                    *symbol =
-                        fields::FieldSymbol::Hour(coarse_hour_cycle.to_skeleton_field_symbol());
-                    break;
-                }
-            }
-        }
-    }
-
-    let skeleton = skeleton::Skeleton::from(&pattern);
-
-    match skeleton::create_best_pattern_for_fields(
-        &datetime.skeletons,
-        &datetime.length_patterns,
-        &skeleton.as_slice(),
-    ) {
-        skeleton::BestSkeleton::AllFieldsMatch(pattern)
-        | skeleton::BestSkeleton::MissingOrExtraFields(pattern) => Some(format!("{}", pattern)),
-        skeleton::BestSkeleton::NoMatch => None,
-    }
-}
diff --git a/components/datetime/src/provider/gregory.rs b/components/datetime/src/provider/gregory.rs
index d62d59946f9..37bbb0de165 100644
--- a/components/datetime/src/provider/gregory.rs
+++ b/components/datetime/src/provider/gregory.rs
@@ -43,7 +43,7 @@ pub struct DatePatternsV1 {
     pub time_h23_h24: patterns::LengthPatternsV1,
 
     /// By default a locale will prefer one hour cycle type over another.
-    pub preferred_hour_cycle: pattern::CoarseHourCycle,
+    pub preferred_hour_cycle: pattern::hour_cycle::CoarseHourCycle,
 
     pub datetime: patterns::DateTimeFormatsV1,
 }
diff --git a/components/datetime/src/provider/helpers.rs b/components/datetime/src/provider/helpers.rs
index c69ef8f20d7..64b6f2dee87 100644
--- a/components/datetime/src/provider/helpers.rs
+++ b/components/datetime/src/provider/helpers.rs
@@ -161,8 +161,8 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
         }
 
         let time = match self.preferred_hour_cycle {
-            crate::pattern::CoarseHourCycle::H11H12 => &self.time_h11_h12,
-            crate::pattern::CoarseHourCycle::H23H24 => &self.time_h23_h24,
+            crate::pattern::hour_cycle::CoarseHourCycle::H11H12 => &self.time_h11_h12,
+            crate::pattern::hour_cycle::CoarseHourCycle::H23H24 => &self.time_h23_h24,
         };
 
         Ok(Pattern::from_bytes(match length {
diff --git a/provider/cldr/src/transform/dates/patterns.rs b/provider/cldr/src/transform/dates/patterns.rs
index 5b2b3597f4b..7acc01f163a 100644
--- a/provider/cldr/src/transform/dates/patterns.rs
+++ b/provider/cldr/src/transform/dates/patterns.rs
@@ -7,7 +7,7 @@ use crate::cldr_langid::CldrLangID;
 use crate::error::Error;
 use crate::reader::{get_subdirectories, open_reader};
 use crate::CldrPaths;
-use icu_datetime::pattern::CoarseHourCycle;
+use icu_datetime::pattern::hour_cycle::CoarseHourCycle;
 use icu_datetime::{pattern, provider::*, skeleton::SkeletonError};
 use icu_provider::iter::{IterableDataProviderCore, KeyedDataProvider};
 use icu_provider::prelude::*;
@@ -198,10 +198,10 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
 
         let mut preferred_hour_cycle: Option<CoarseHourCycle> = None;
         for hour_cycle in [
-            pattern::determine_coarse_hour_cycle(&pattern_full),
-            pattern::determine_coarse_hour_cycle(&pattern_long),
-            pattern::determine_coarse_hour_cycle(&pattern_medium),
-            pattern::determine_coarse_hour_cycle(&pattern_short),
+            pattern::hour_cycle::determine_coarse_hour_cycle(&pattern_full),
+            pattern::hour_cycle::determine_coarse_hour_cycle(&pattern_long),
+            pattern::hour_cycle::determine_coarse_hour_cycle(&pattern_medium),
+            pattern::hour_cycle::determine_coarse_hour_cycle(&pattern_short),
         ]
         .iter()
         {
@@ -219,16 +219,16 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
 
         let preferred_hour_cycle =
             preferred_hour_cycle.expect("Could not find a preferred hour cycle.");
-        let alt_hour_cycle = if preferred_hour_cycle == pattern::CoarseHourCycle::H11H12 {
-            pattern::CoarseHourCycle::H23H24
+        let alt_hour_cycle = if preferred_hour_cycle == CoarseHourCycle::H11H12 {
+            CoarseHourCycle::H23H24
         } else {
-            pattern::CoarseHourCycle::H11H12
+            CoarseHourCycle::H11H12
         };
 
         let (time_h11_h12, time_h23_h24) = {
             let time = (&other.calendars.gregorian.time_formats).into();
             let alt_time = gregory::patterns::LengthPatternsV1 {
-                full: pattern::apply_coarse_hour_cycle(
+                full: pattern::hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_full,
                     pattern_full,
@@ -236,7 +236,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                long: pattern::apply_coarse_hour_cycle(
+                long: pattern::hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_long,
                     pattern_long,
@@ -244,7 +244,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                medium: pattern::apply_coarse_hour_cycle(
+                medium: pattern::hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_medium,
                     pattern_medium,
@@ -252,7 +252,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                short: pattern::apply_coarse_hour_cycle(
+                short: pattern::hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_short,
                     pattern_short,

From 4c6f00cca0687954cb3d75db810453a2b318d3e8 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Fri, 2 Jul 2021 11:50:11 -0500
Subject: [PATCH 05/17] Add a feature flag provider_transform_utils, and apply
 it to the hour cycle transform code

---
 components/datetime/Cargo.toml                |  1 +
 components/datetime/src/pattern/mod.rs        | 23 +++++-
 ...{hour_cycle.rs => transform_hour_cycle.rs} | 79 +++++++------------
 components/datetime/src/provider/gregory.rs   |  2 +-
 components/datetime/src/provider/helpers.rs   |  4 +-
 components/datetime/src/skeleton.rs           | 11 ++-
 components/icu/README.md                      |  3 +
 provider/cldr/Cargo.toml                      |  2 +-
 provider/cldr/src/transform/dates/patterns.rs | 18 ++---
 9 files changed, 78 insertions(+), 65 deletions(-)
 rename components/datetime/src/pattern/{hour_cycle.rs => transform_hour_cycle.rs} (54%)

diff --git a/components/datetime/Cargo.toml b/components/datetime/Cargo.toml
index b28d0e443da..37ab7260f0b 100644
--- a/components/datetime/Cargo.toml
+++ b/components/datetime/Cargo.toml
@@ -57,6 +57,7 @@ bench = false  # This option is required for Benchmark CI
 default = ["provider_serde"]
 bench = []
 provider_serde = ["serde", "litemap/serde"]
+provider_transform_utils = []
 
 [[bench]]
 name = "datetime"
diff --git a/components/datetime/src/pattern/mod.rs b/components/datetime/src/pattern/mod.rs
index 56da9802a22..e0676bb357b 100644
--- a/components/datetime/src/pattern/mod.rs
+++ b/components/datetime/src/pattern/mod.rs
@@ -3,8 +3,8 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 mod error;
-pub mod hour_cycle;
 mod parser;
+pub mod transform_hour_cycle;
 
 use crate::fields::{self, Field, FieldLength, FieldSymbol};
 pub use error::Error;
@@ -286,3 +286,24 @@ impl Serialize for Pattern {
         }
     }
 }
+
+/// Used to represent either H11/H12, or H23/H24. Skeletons only store these
+/// hour cycles as H12 or H24.
+#[derive(Debug, PartialEq, Clone, Copy)]
+#[cfg_attr(
+    feature = "provider_serde",
+    derive(serde::Serialize, serde::Deserialize)
+)]
+pub enum CoarseHourCycle {
+    /// Can either be fields::Hour::H11 or fields::Hour::H12
+    H11H12,
+    /// Can either be fields::Hour::H23 or fields::Hour::H24
+    H23H24,
+}
+
+/// Default is required for serialization, arbitrarily pick one.
+impl Default for CoarseHourCycle {
+    fn default() -> Self {
+        CoarseHourCycle::H11H12
+    }
+}
diff --git a/components/datetime/src/pattern/hour_cycle.rs b/components/datetime/src/pattern/transform_hour_cycle.rs
similarity index 54%
rename from components/datetime/src/pattern/hour_cycle.rs
rename to components/datetime/src/pattern/transform_hour_cycle.rs
index 0b1b855f217..4eeea289849 100644
--- a/components/datetime/src/pattern/hour_cycle.rs
+++ b/components/datetime/src/pattern/transform_hour_cycle.rs
@@ -1,52 +1,20 @@
-use crate::fields;
-use crate::pattern::{Pattern, PatternItem};
-use crate::provider;
-use crate::skeleton;
+// 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 ).
 
-/// Used to represent either H11/H12, or H23/H24. Skeletons only store these
-/// hour cycles as H12 or H24.
-#[derive(Debug, PartialEq, Clone, Copy)]
-#[cfg_attr(
-    feature = "provider_serde",
-    derive(serde::Serialize, serde::Deserialize)
-)]
-pub enum CoarseHourCycle {
-    /// Can either be fields::Hour::H11 or fields::Hour::H12
-    H11H12,
-    /// Can either be fields::Hour::H23 or fields::Hour::H24
-    H23H24,
-}
+//! This hour cycle module represents various utilities for working with hour cycles in order
+//! to apply a user preference.
 
-/// Default is required for serialization, arbitrarily pick one.
-impl Default for CoarseHourCycle {
-    fn default() -> Self {
-        CoarseHourCycle::H11H12
-    }
-}
+#![doc(hidden)]
+#![cfg(feature = "provider_transform_utils")]
 
-impl CoarseHourCycle {
-    pub fn matches_field(&self, hour: &fields::Hour) -> bool {
-        match self {
-            CoarseHourCycle::H11H12 => match hour {
-                fields::Hour::H11 | fields::Hour::H12 => true,
-                fields::Hour::H23 | fields::Hour::H24 => false,
-            },
-            CoarseHourCycle::H23H24 => match hour {
-                fields::Hour::H11 | fields::Hour::H12 => false,
-                fields::Hour::H23 | fields::Hour::H24 => true,
-            },
-        }
-    }
-
-    /// Skeletons only use h12 and h24.
-    fn to_skeleton_field_symbol(&self) -> fields::Hour {
-        match self {
-            CoarseHourCycle::H11H12 => fields::Hour::H12,
-            CoarseHourCycle::H23H24 => fields::Hour::H24,
-        }
-    }
-}
+use crate::fields;
+use crate::pattern::{CoarseHourCycle, Pattern, PatternItem};
+use crate::provider;
+use crate::skeleton;
 
+/// Figure out the coarse hour cycle given a pattern, which is useful for generating the provider
+/// patterns for `length::Bag`.
 pub fn determine_coarse_hour_cycle(pattern: &Pattern) -> Option<CoarseHourCycle> {
     for item in pattern.items() {
         if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
@@ -63,7 +31,9 @@ pub fn determine_coarse_hour_cycle(pattern: &Pattern) -> Option<CoarseHourCycle>
 }
 
 /// Invoke the pattern matching machinery to transform the hour cycle of a pattern. This provides
-/// a safe mapping from a h11/h12 to h23/h24
+/// a safe mapping from a h11/h12 to h23/h24 for transforms.
+#[doc(hidden)]
+#[cfg(feature = "provider_transform_utils")]
 pub fn apply_coarse_hour_cycle(
     datetime: &provider::gregory::patterns::DateTimeFormatsV1,
     pattern_str: &str,
@@ -73,14 +43,25 @@ pub fn apply_coarse_hour_cycle(
     for item in pattern.items_mut() {
         if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
             if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
-                if coarse_hour_cycle.matches_field(pattern_hour) {
+                if match coarse_hour_cycle {
+                    CoarseHourCycle::H11H12 => match pattern_hour {
+                        fields::Hour::H11 | fields::Hour::H12 => true,
+                        fields::Hour::H23 | fields::Hour::H24 => false,
+                    },
+                    CoarseHourCycle::H23H24 => match pattern_hour {
+                        fields::Hour::H11 | fields::Hour::H12 => false,
+                        fields::Hour::H23 | fields::Hour::H24 => true,
+                    },
+                } {
                     // The preference hour cycle matches the pattern, bail out early and
                     // return the current pattern.
                     return Some(pattern_str.into());
                 } else {
                     // Mutate the pattern with the new symbol, so that it can be matched against.
-                    *symbol =
-                        fields::FieldSymbol::Hour(coarse_hour_cycle.to_skeleton_field_symbol());
+                    *symbol = fields::FieldSymbol::Hour(match coarse_hour_cycle {
+                        CoarseHourCycle::H11H12 => fields::Hour::H12,
+                        CoarseHourCycle::H23H24 => fields::Hour::H24,
+                    });
                     break;
                 }
             }
diff --git a/components/datetime/src/provider/gregory.rs b/components/datetime/src/provider/gregory.rs
index 37bbb0de165..d62d59946f9 100644
--- a/components/datetime/src/provider/gregory.rs
+++ b/components/datetime/src/provider/gregory.rs
@@ -43,7 +43,7 @@ pub struct DatePatternsV1 {
     pub time_h23_h24: patterns::LengthPatternsV1,
 
     /// By default a locale will prefer one hour cycle type over another.
-    pub preferred_hour_cycle: pattern::hour_cycle::CoarseHourCycle,
+    pub preferred_hour_cycle: pattern::CoarseHourCycle,
 
     pub datetime: patterns::DateTimeFormatsV1,
 }
diff --git a/components/datetime/src/provider/helpers.rs b/components/datetime/src/provider/helpers.rs
index 64b6f2dee87..c69ef8f20d7 100644
--- a/components/datetime/src/provider/helpers.rs
+++ b/components/datetime/src/provider/helpers.rs
@@ -161,8 +161,8 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
         }
 
         let time = match self.preferred_hour_cycle {
-            crate::pattern::hour_cycle::CoarseHourCycle::H11H12 => &self.time_h11_h12,
-            crate::pattern::hour_cycle::CoarseHourCycle::H23H24 => &self.time_h23_h24,
+            crate::pattern::CoarseHourCycle::H11H12 => &self.time_h11_h12,
+            crate::pattern::CoarseHourCycle::H23H24 => &self.time_h23_h24,
         };
 
         Ok(Pattern::from_bytes(match length {
diff --git a/components/datetime/src/skeleton.rs b/components/datetime/src/skeleton.rs
index 3f6bc73810f..987f2b45afe 100644
--- a/components/datetime/src/skeleton.rs
+++ b/components/datetime/src/skeleton.rs
@@ -11,7 +11,7 @@ use thiserror::Error;
 use crate::{
     fields::{self, Field, FieldLength, FieldSymbol},
     options::length,
-    pattern::{Pattern, PatternItem},
+    pattern::Pattern,
     provider::gregory::patterns::{LengthPatternsV1, PatternV1, SkeletonV1, SkeletonsV1},
 };
 
@@ -204,11 +204,16 @@ impl TryFrom<&str> for Skeleton {
 /// the fields into the canonical sort order. Not all fields are supported by Skeletons, so map
 /// fields into skeleton-appropriate ones. For instance, in the "ja" locale the pattern "aK:mm"
 /// gets transformed into the skeleton "hmm".
+///
+/// At the time of this writing, it's being used for applying hour cycle preferences and should not
+/// be exposed as a public API for end users.
+#[doc(hidden)]
+#[cfg(feature = "provider_transform_utils")]
 impl From<&Pattern> for Skeleton {
     fn from(pattern: &Pattern) -> Self {
         let mut fields: SmallVec<[fields::Field; 5]> = SmallVec::new();
         for item in pattern.items() {
-            if let PatternItem::Field(field) = item {
+            if let crate::pattern::PatternItem::Field(field) = item {
                 let mut field = *field;
 
                 // Skeletons only have a subset of available fields, these are then mapped to more
@@ -1049,6 +1054,7 @@ mod test {
         );
     }
 
+    #[cfg(feature = "provider_transform_utils")]
     fn assert_pattern_to_skeleton(pattern: &str, skeleton: &str, message: &str) {
         assert_eq!(
             serde_json::to_string(skeleton).unwrap(),
@@ -1059,6 +1065,7 @@ mod test {
     }
 
     #[test]
+    #[cfg(feature = "provider_transform_utils")]
     fn test_pattern_to_skeleton() {
         assert_pattern_to_skeleton("H:mm:ss v", "Hmmssv", "Test a complicated time pattern");
 
diff --git a/components/icu/README.md b/components/icu/README.md
index a319e95ad93..8157550ac1e 100644
--- a/components/icu/README.md
+++ b/components/icu/README.md
@@ -44,6 +44,9 @@ functionality are compiled. These features are:
   when running `cargo bench`.
 - `experimental`: Whether to enable experimental preview features. Modules enabled with
   this feature may not be production-ready and could change at any time.
+- `provider_transform_utils`: This is code that is useful for transforming CLDR data, but
+  may be risky to ship as a public API. For instance in DateTimeFormat code we may want to
+  manipulate patterns, but not allow end users to do the same.
 
 ## Example
 
diff --git a/provider/cldr/Cargo.toml b/provider/cldr/Cargo.toml
index 9a73a73461d..6dc728866fc 100644
--- a/provider/cldr/Cargo.toml
+++ b/provider/cldr/Cargo.toml
@@ -36,7 +36,7 @@ all-features = true
 icu_provider = { version = "0.2", path = "../../provider/core", features = ["provider_serde"] }
 icu_locid = { version = "0.2", path = "../../components/locid" }
 icu_plurals = { version = "0.2", path = "../../components/plurals" }
-icu_datetime = { version = "0.2", path = "../../components/datetime" }
+icu_datetime = { version = "0.2", path = "../../components/datetime", features = ["provider_transform_utils"] }
 icu_locale_canonicalizer = { version = "0.2", path = "../../components/locale_canonicalizer" }
 icu_decimal = { version = "0.2", path = "../../components/decimal" }
 itertools = "0.10"
diff --git a/provider/cldr/src/transform/dates/patterns.rs b/provider/cldr/src/transform/dates/patterns.rs
index 7acc01f163a..b532eb17bbf 100644
--- a/provider/cldr/src/transform/dates/patterns.rs
+++ b/provider/cldr/src/transform/dates/patterns.rs
@@ -7,7 +7,7 @@ use crate::cldr_langid::CldrLangID;
 use crate::error::Error;
 use crate::reader::{get_subdirectories, open_reader};
 use crate::CldrPaths;
-use icu_datetime::pattern::hour_cycle::CoarseHourCycle;
+use icu_datetime::pattern::CoarseHourCycle;
 use icu_datetime::{pattern, provider::*, skeleton::SkeletonError};
 use icu_provider::iter::{IterableDataProviderCore, KeyedDataProvider};
 use icu_provider::prelude::*;
@@ -198,10 +198,10 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
 
         let mut preferred_hour_cycle: Option<CoarseHourCycle> = None;
         for hour_cycle in [
-            pattern::hour_cycle::determine_coarse_hour_cycle(&pattern_full),
-            pattern::hour_cycle::determine_coarse_hour_cycle(&pattern_long),
-            pattern::hour_cycle::determine_coarse_hour_cycle(&pattern_medium),
-            pattern::hour_cycle::determine_coarse_hour_cycle(&pattern_short),
+            pattern::transform_hour_cycle::determine_coarse_hour_cycle(&pattern_full),
+            pattern::transform_hour_cycle::determine_coarse_hour_cycle(&pattern_long),
+            pattern::transform_hour_cycle::determine_coarse_hour_cycle(&pattern_medium),
+            pattern::transform_hour_cycle::determine_coarse_hour_cycle(&pattern_short),
         ]
         .iter()
         {
@@ -228,7 +228,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
         let (time_h11_h12, time_h23_h24) = {
             let time = (&other.calendars.gregorian.time_formats).into();
             let alt_time = gregory::patterns::LengthPatternsV1 {
-                full: pattern::hour_cycle::apply_coarse_hour_cycle(
+                full: pattern::transform_hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_full,
                     pattern_full,
@@ -236,7 +236,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                long: pattern::hour_cycle::apply_coarse_hour_cycle(
+                long: pattern::transform_hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_long,
                     pattern_long,
@@ -244,7 +244,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                medium: pattern::hour_cycle::apply_coarse_hour_cycle(
+                medium: pattern::transform_hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_medium,
                     pattern_medium,
@@ -252,7 +252,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 )
                 .unwrap()
                 .into(),
-                short: pattern::hour_cycle::apply_coarse_hour_cycle(
+                short: pattern::transform_hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
                     &pattern_str_short,
                     pattern_short,

From dc732131f05376e55d66655cd827eda605065106 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Fri, 2 Jul 2021 12:04:35 -0500
Subject: [PATCH 06/17] Correct H23 as the stored symbol for skeletons

---
 components/datetime/src/pattern/mod.rs                  | 2 +-
 components/datetime/src/pattern/transform_hour_cycle.rs | 2 +-
 components/datetime/src/skeleton.rs                     | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/components/datetime/src/pattern/mod.rs b/components/datetime/src/pattern/mod.rs
index e0676bb357b..1d93b125624 100644
--- a/components/datetime/src/pattern/mod.rs
+++ b/components/datetime/src/pattern/mod.rs
@@ -288,7 +288,7 @@ impl Serialize for Pattern {
 }
 
 /// Used to represent either H11/H12, or H23/H24. Skeletons only store these
-/// hour cycles as H12 or H24.
+/// hour cycles as H12 or H23.
 #[derive(Debug, PartialEq, Clone, Copy)]
 #[cfg_attr(
     feature = "provider_serde",
diff --git a/components/datetime/src/pattern/transform_hour_cycle.rs b/components/datetime/src/pattern/transform_hour_cycle.rs
index 4eeea289849..f3be801f872 100644
--- a/components/datetime/src/pattern/transform_hour_cycle.rs
+++ b/components/datetime/src/pattern/transform_hour_cycle.rs
@@ -60,7 +60,7 @@ pub fn apply_coarse_hour_cycle(
                     // Mutate the pattern with the new symbol, so that it can be matched against.
                     *symbol = fields::FieldSymbol::Hour(match coarse_hour_cycle {
                         CoarseHourCycle::H11H12 => fields::Hour::H12,
-                        CoarseHourCycle::H23H24 => fields::Hour::H24,
+                        CoarseHourCycle::H23H24 => fields::Hour::H23,
                     });
                     break;
                 }
diff --git a/components/datetime/src/skeleton.rs b/components/datetime/src/skeleton.rs
index 987f2b45afe..ef5e51532d0 100644
--- a/components/datetime/src/skeleton.rs
+++ b/components/datetime/src/skeleton.rs
@@ -236,13 +236,13 @@ impl From<&Pattern> for Skeleton {
                     //     FieldSymbol::DayPeriod(fields::DayPeriod::Flexible)
                     // }
 
-                    // Only the H12 and H24 symbols are used in skeletons, while the patterns may
+                    // Only the H12 and H23 symbols are used in skeletons, while the patterns may
                     // contain H11 or H23 depending on the localization.
                     FieldSymbol::Hour(fields::Hour::H11) | FieldSymbol::Hour(fields::Hour::H12) => {
                         FieldSymbol::Hour(fields::Hour::H12)
                     }
                     FieldSymbol::Hour(fields::Hour::H23) | FieldSymbol::Hour(fields::Hour::H24) => {
-                        FieldSymbol::Hour(fields::Hour::H24)
+                        FieldSymbol::Hour(fields::Hour::H23)
                     }
 
                     // Pass through all of the following preferences unchanged.

From b80883a7dd324ae0418ed6ce88bab824cc5cedcc Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Fri, 2 Jul 2021 12:08:20 -0500
Subject: [PATCH 07/17] Fix CI by running `cargo make generate-readmes`

---
 components/icu/src/lib.rs       | 3 +++
 experimental/calendar/README.md | 7 +++++++
 2 files changed, 10 insertions(+)
 create mode 100644 experimental/calendar/README.md

diff --git a/components/icu/src/lib.rs b/components/icu/src/lib.rs
index 486dbbb1a71..972f90abc0e 100644
--- a/components/icu/src/lib.rs
+++ b/components/icu/src/lib.rs
@@ -46,6 +46,9 @@
 //!   when running `cargo bench`.
 //! - `experimental`: Whether to enable experimental preview features. Modules enabled with
 //!   this feature may not be production-ready and could change at any time.
+//! - `provider_transform_utils`: This is code that is useful for transforming CLDR data, but
+//!   may be risky to ship as a public API. For instance in DateTimeFormat code we may want to
+//!   manipulate patterns, but not allow end users to do the same.
 //!
 //! # Example
 //!
diff --git a/experimental/calendar/README.md b/experimental/calendar/README.md
new file mode 100644
index 00000000000..7e83be37d92
--- /dev/null
+++ b/experimental/calendar/README.md
@@ -0,0 +1,7 @@
+# icu_calendar [![crates.io](http://meritbadge.herokuapp.com/icu_calendar)](https://crates.io/crates/icu_calendar)
+
+
+
+## More Information
+
+For more information on development, authorship, contributing etc. please visit [`ICU4X home page`](https://github.com/unicode-org/icu4x).

From e7525093ce781ce984f6578d6f29ff92d6c6634d Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Tue, 6 Jul 2021 09:41:58 -0500
Subject: [PATCH 08/17] Change the default CoarseHourCycle

---
 components/datetime/src/pattern/mod.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/components/datetime/src/pattern/mod.rs b/components/datetime/src/pattern/mod.rs
index 1d93b125624..7da4f9c53ea 100644
--- a/components/datetime/src/pattern/mod.rs
+++ b/components/datetime/src/pattern/mod.rs
@@ -301,9 +301,10 @@ pub enum CoarseHourCycle {
     H23H24,
 }
 
-/// Default is required for serialization, arbitrarily pick one.
+/// Default is required for serialization. H23H24 is the more locale-agnostic choice, as it's
+/// less likely to have a day period in it.
 impl Default for CoarseHourCycle {
     fn default() -> Self {
-        CoarseHourCycle::H11H12
+        CoarseHourCycle::H23H24
     }
 }

From 1bedace45f185c72c1c78486979a142fbedb2422 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Tue, 6 Jul 2021 10:25:05 -0500
Subject: [PATCH 09/17] Rename provider_transform_utils to
 provider_transform_internals

---
 components/datetime/Cargo.toml                          | 2 +-
 components/datetime/src/pattern/transform_hour_cycle.rs | 4 ++--
 components/datetime/src/skeleton.rs                     | 6 +++---
 components/icu/README.md                                | 2 +-
 components/icu/src/lib.rs                               | 2 +-
 provider/cldr/Cargo.toml                                | 2 +-
 6 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/components/datetime/Cargo.toml b/components/datetime/Cargo.toml
index 37ab7260f0b..7cf6f8b1b5a 100644
--- a/components/datetime/Cargo.toml
+++ b/components/datetime/Cargo.toml
@@ -57,7 +57,7 @@ bench = false  # This option is required for Benchmark CI
 default = ["provider_serde"]
 bench = []
 provider_serde = ["serde", "litemap/serde"]
-provider_transform_utils = []
+provider_transform_internals = []
 
 [[bench]]
 name = "datetime"
diff --git a/components/datetime/src/pattern/transform_hour_cycle.rs b/components/datetime/src/pattern/transform_hour_cycle.rs
index f3be801f872..bbf5d2d5981 100644
--- a/components/datetime/src/pattern/transform_hour_cycle.rs
+++ b/components/datetime/src/pattern/transform_hour_cycle.rs
@@ -6,7 +6,7 @@
 //! to apply a user preference.
 
 #![doc(hidden)]
-#![cfg(feature = "provider_transform_utils")]
+#![cfg(feature = "provider_transform_internals")]
 
 use crate::fields;
 use crate::pattern::{CoarseHourCycle, Pattern, PatternItem};
@@ -33,7 +33,7 @@ pub fn determine_coarse_hour_cycle(pattern: &Pattern) -> Option<CoarseHourCycle>
 /// Invoke the pattern matching machinery to transform the hour cycle of a pattern. This provides
 /// a safe mapping from a h11/h12 to h23/h24 for transforms.
 #[doc(hidden)]
-#[cfg(feature = "provider_transform_utils")]
+#[cfg(feature = "provider_transform_internals")]
 pub fn apply_coarse_hour_cycle(
     datetime: &provider::gregory::patterns::DateTimeFormatsV1,
     pattern_str: &str,
diff --git a/components/datetime/src/skeleton.rs b/components/datetime/src/skeleton.rs
index ef5e51532d0..372c1abb064 100644
--- a/components/datetime/src/skeleton.rs
+++ b/components/datetime/src/skeleton.rs
@@ -208,7 +208,7 @@ impl TryFrom<&str> for Skeleton {
 /// At the time of this writing, it's being used for applying hour cycle preferences and should not
 /// be exposed as a public API for end users.
 #[doc(hidden)]
-#[cfg(feature = "provider_transform_utils")]
+#[cfg(feature = "provider_transform_internals")]
 impl From<&Pattern> for Skeleton {
     fn from(pattern: &Pattern) -> Self {
         let mut fields: SmallVec<[fields::Field; 5]> = SmallVec::new();
@@ -1054,7 +1054,7 @@ mod test {
         );
     }
 
-    #[cfg(feature = "provider_transform_utils")]
+    #[cfg(feature = "provider_transform_internals")]
     fn assert_pattern_to_skeleton(pattern: &str, skeleton: &str, message: &str) {
         assert_eq!(
             serde_json::to_string(skeleton).unwrap(),
@@ -1065,7 +1065,7 @@ mod test {
     }
 
     #[test]
-    #[cfg(feature = "provider_transform_utils")]
+    #[cfg(feature = "provider_transform_internals")]
     fn test_pattern_to_skeleton() {
         assert_pattern_to_skeleton("H:mm:ss v", "Hmmssv", "Test a complicated time pattern");
 
diff --git a/components/icu/README.md b/components/icu/README.md
index 8157550ac1e..11cafe454b9 100644
--- a/components/icu/README.md
+++ b/components/icu/README.md
@@ -44,7 +44,7 @@ functionality are compiled. These features are:
   when running `cargo bench`.
 - `experimental`: Whether to enable experimental preview features. Modules enabled with
   this feature may not be production-ready and could change at any time.
-- `provider_transform_utils`: This is code that is useful for transforming CLDR data, but
+- `provider_transform_internals`: This is code that is useful for transforming CLDR data, but
   may be risky to ship as a public API. For instance in DateTimeFormat code we may want to
   manipulate patterns, but not allow end users to do the same.
 
diff --git a/components/icu/src/lib.rs b/components/icu/src/lib.rs
index 972f90abc0e..f7b3165bf08 100644
--- a/components/icu/src/lib.rs
+++ b/components/icu/src/lib.rs
@@ -46,7 +46,7 @@
 //!   when running `cargo bench`.
 //! - `experimental`: Whether to enable experimental preview features. Modules enabled with
 //!   this feature may not be production-ready and could change at any time.
-//! - `provider_transform_utils`: This is code that is useful for transforming CLDR data, but
+//! - `provider_transform_internals`: This is code that is useful for transforming CLDR data, but
 //!   may be risky to ship as a public API. For instance in DateTimeFormat code we may want to
 //!   manipulate patterns, but not allow end users to do the same.
 //!
diff --git a/provider/cldr/Cargo.toml b/provider/cldr/Cargo.toml
index 6dc728866fc..6aa4de4cadd 100644
--- a/provider/cldr/Cargo.toml
+++ b/provider/cldr/Cargo.toml
@@ -36,7 +36,7 @@ all-features = true
 icu_provider = { version = "0.2", path = "../../provider/core", features = ["provider_serde"] }
 icu_locid = { version = "0.2", path = "../../components/locid" }
 icu_plurals = { version = "0.2", path = "../../components/plurals" }
-icu_datetime = { version = "0.2", path = "../../components/datetime", features = ["provider_transform_utils"] }
+icu_datetime = { version = "0.2", path = "../../components/datetime", features = ["provider_transform_internals"] }
 icu_locale_canonicalizer = { version = "0.2", path = "../../components/locale_canonicalizer" }
 icu_decimal = { version = "0.2", path = "../../components/decimal" }
 itertools = "0.10"

From 96b09eefda83ae21c0c8acb6d5a828b178661a78 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Tue, 6 Jul 2021 10:39:15 -0500
Subject: [PATCH 10/17] Refactor Skeleton::from(pattern)

---
 components/datetime/src/skeleton.rs | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/components/datetime/src/skeleton.rs b/components/datetime/src/skeleton.rs
index 372c1abb064..789d8bb7582 100644
--- a/components/datetime/src/skeleton.rs
+++ b/components/datetime/src/skeleton.rs
@@ -219,13 +219,9 @@ impl From<&Pattern> for Skeleton {
                 // Skeletons only have a subset of available fields, these are then mapped to more
                 // specific fields for the patterns they expand to.
                 field.symbol = match field.symbol {
-                    FieldSymbol::Year(year) => FieldSymbol::Year(year),
-                    // Remove the stand-alone designation. This will be provided by the pattern.
-                    FieldSymbol::Month(fields::Month::Format)
-                    | FieldSymbol::Month(fields::Month::StandAlone) => {
-                        FieldSymbol::Month(fields::Month::Format)
-                    }
-                    FieldSymbol::Day(day) => FieldSymbol::Day(day),
+                    // Only the format varieties are used in the skeletons, the matched patterns
+                    // will be more specific.
+                    FieldSymbol::Month(_) => FieldSymbol::Month(fields::Month::Format),
                     FieldSymbol::Weekday(_) => FieldSymbol::Weekday(fields::Weekday::Format),
 
                     // Only flexible day periods are used in skeletons, ignore all others.
@@ -246,9 +242,11 @@ impl From<&Pattern> for Skeleton {
                     }
 
                     // Pass through all of the following preferences unchanged.
-                    FieldSymbol::Minute => FieldSymbol::Minute,
-                    FieldSymbol::Second(second) => FieldSymbol::Second(second),
-                    FieldSymbol::TimeZone(time_zone) => FieldSymbol::TimeZone(time_zone),
+                    FieldSymbol::Minute
+                    | FieldSymbol::Second(_)
+                    | FieldSymbol::TimeZone(_)
+                    | FieldSymbol::Year(_)
+                    | FieldSymbol::Day(_) => field.symbol,
                 };
 
                 // Only insert if it's a unique field.
@@ -1068,6 +1066,11 @@ mod test {
     #[cfg(feature = "provider_transform_internals")]
     fn test_pattern_to_skeleton() {
         assert_pattern_to_skeleton("H:mm:ss v", "Hmmssv", "Test a complicated time pattern");
+        assert_pattern_to_skeleton(
+            "v ss:mm:H",
+            "Hmmssv",
+            "Test the skeleton ordering is consistent",
+        );
 
         assert_pattern_to_skeleton("K:mm", "hmm", "H11 maps to H12");
         assert_pattern_to_skeleton("k:mm", "Hmm", "H23 maps to H24");

From 468c2009f4c9a75e102f493bf0c700212193e950 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Tue, 6 Jul 2021 10:39:32 -0500
Subject: [PATCH 11/17] Rewrite all unwrap() to expect()

---
 components/datetime/src/skeleton.rs           |  7 +++++--
 provider/cldr/src/transform/dates/patterns.rs | 20 +++++++++++--------
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/components/datetime/src/skeleton.rs b/components/datetime/src/skeleton.rs
index 789d8bb7582..ab946f9f4ca 100644
--- a/components/datetime/src/skeleton.rs
+++ b/components/datetime/src/skeleton.rs
@@ -1055,8 +1055,11 @@ mod test {
     #[cfg(feature = "provider_transform_internals")]
     fn assert_pattern_to_skeleton(pattern: &str, skeleton: &str, message: &str) {
         assert_eq!(
-            serde_json::to_string(skeleton).unwrap(),
-            serde_json::to_string(&Skeleton::from(&Pattern::from_bytes(pattern).unwrap())).unwrap(),
+            serde_json::to_string(skeleton).expect("Failed to transform skeleton to string."),
+            serde_json::to_string(&Skeleton::from(
+                &Pattern::from_bytes(pattern).expect("Failed to create pattern from bytes.")
+            ))
+            .expect("Failed to transform skeleton to string."),
             "{}",
             message
         );
diff --git a/provider/cldr/src/transform/dates/patterns.rs b/provider/cldr/src/transform/dates/patterns.rs
index b532eb17bbf..b2c02bb9142 100644
--- a/provider/cldr/src/transform/dates/patterns.rs
+++ b/provider/cldr/src/transform/dates/patterns.rs
@@ -191,10 +191,14 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
         let pattern_str_medium = other.calendars.gregorian.time_formats.medium.get_pattern();
         let pattern_str_short = other.calendars.gregorian.time_formats.short.get_pattern();
 
-        let pattern_full = pattern::Pattern::from_bytes(pattern_str_full).unwrap();
-        let pattern_long = pattern::Pattern::from_bytes(pattern_str_long).unwrap();
-        let pattern_medium = pattern::Pattern::from_bytes(pattern_str_medium).unwrap();
-        let pattern_short = pattern::Pattern::from_bytes(pattern_str_short).unwrap();
+        let pattern_full = pattern::Pattern::from_bytes(pattern_str_full)
+            .expect("Failed to create a full Pattern from bytes.");
+        let pattern_long = pattern::Pattern::from_bytes(pattern_str_long)
+            .expect("Failed to create a long Pattern from bytes.");
+        let pattern_medium = pattern::Pattern::from_bytes(pattern_str_medium)
+            .expect("Failed to create a medium Pattern from bytes.");
+        let pattern_short = pattern::Pattern::from_bytes(pattern_str_short)
+            .expect("Failed to create a short Pattern from bytes.");
 
         let mut preferred_hour_cycle: Option<CoarseHourCycle> = None;
         for hour_cycle in [
@@ -234,7 +238,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                     pattern_full,
                     alt_hour_cycle,
                 )
-                .unwrap()
+                .expect("Failed to apply a coarse hour cycle to a full pattern.")
                 .into(),
                 long: pattern::transform_hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
@@ -242,7 +246,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                     pattern_long,
                     alt_hour_cycle,
                 )
-                .unwrap()
+                .expect("Failed to apply a coarse hour cycle to a long pattern.")
                 .into(),
                 medium: pattern::transform_hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
@@ -250,7 +254,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                     pattern_medium,
                     alt_hour_cycle,
                 )
-                .unwrap()
+                .expect("Failed to apply a coarse hour cycle to a medium pattern.")
                 .into(),
                 short: pattern::transform_hour_cycle::apply_coarse_hour_cycle(
                     &date_time_formats_v1,
@@ -258,7 +262,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                     pattern_short,
                     alt_hour_cycle,
                 )
-                .unwrap()
+                .expect("Failed to apply a coarse hour cycle to a short pattern.")
                 .into(),
             };
 

From 270100645e8e627b4bd29a89e8d4fa10c1de64f1 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Tue, 6 Jul 2021 10:54:00 -0500
Subject: [PATCH 12/17] Refactor get_pattern_for_time_length

---
 components/datetime/src/provider/helpers.rs | 47 ++++++++++++---------
 1 file changed, 26 insertions(+), 21 deletions(-)

diff --git a/components/datetime/src/provider/helpers.rs b/components/datetime/src/provider/helpers.rs
index c69ef8f20d7..59a743e5b35 100644
--- a/components/datetime/src/provider/helpers.rs
+++ b/components/datetime/src/provider/helpers.rs
@@ -135,21 +135,36 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
         length: length::Time,
         preferences: &Option<preferences::Bag>,
     ) -> Result<Pattern> {
-        // Apply the hour cycle preference if it exists.
-        if let Some(preferences::Bag {
+        // Determine the coarse hour cycle patterns to use from either the preference bag,
+        // or the preferred hour cycle for the locale.
+        let time = if let Some(preferences::Bag {
             hour_cycle: Some(hour_cycle_pref),
         }) = preferences
         {
-            let time = match hour_cycle_pref {
+            match hour_cycle_pref {
                 preferences::HourCycle::H11 | preferences::HourCycle::H12 => &self.time_h11_h12,
                 preferences::HourCycle::H23 | preferences::HourCycle::H24 => &self.time_h23_h24,
-            };
-            let mut pattern = Pattern::from_bytes(match length {
-                length::Time::Full => &time.full,
-                length::Time::Long => &time.long,
-                length::Time::Medium => &time.medium,
-                length::Time::Short => &time.short,
-            })?;
+            }
+        } else {
+            match self.preferred_hour_cycle {
+                crate::pattern::CoarseHourCycle::H11H12 => &self.time_h11_h12,
+                crate::pattern::CoarseHourCycle::H23H24 => &self.time_h23_h24,
+            }
+        };
+
+        let mut pattern = Pattern::from_bytes(match length {
+            length::Time::Full => &time.full,
+            length::Time::Long => &time.long,
+            length::Time::Medium => &time.medium,
+            length::Time::Short => &time.short,
+        })?;
+
+        if let Some(preferences::Bag {
+            hour_cycle: Some(hour_cycle_pref),
+        }) = preferences
+        {
+            // Apply the preference::Bag override and change the pattern from a coarse hour cycle
+            // to the specific hour cycle.
             for item in pattern.items_mut() {
                 if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
                     if let fields::FieldSymbol::Hour(_) = symbol {
@@ -160,17 +175,7 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
             return Ok(pattern);
         }
 
-        let time = match self.preferred_hour_cycle {
-            crate::pattern::CoarseHourCycle::H11H12 => &self.time_h11_h12,
-            crate::pattern::CoarseHourCycle::H23H24 => &self.time_h23_h24,
-        };
-
-        Ok(Pattern::from_bytes(match length {
-            length::Time::Full => &time.full,
-            length::Time::Long => &time.long,
-            length::Time::Medium => &time.medium,
-            length::Time::Short => &time.short,
-        })?)
+        Ok(pattern)
     }
 }
 

From 69fe327ebcd1fbd7b0c4527dee77d057294d7c56 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Tue, 6 Jul 2021 13:34:50 -0500
Subject: [PATCH 13/17] Fix clippy issue with nested match

---
 .../datetime/src/pattern/transform_hour_cycle.rs | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/components/datetime/src/pattern/transform_hour_cycle.rs b/components/datetime/src/pattern/transform_hour_cycle.rs
index bbf5d2d5981..841888f6246 100644
--- a/components/datetime/src/pattern/transform_hour_cycle.rs
+++ b/components/datetime/src/pattern/transform_hour_cycle.rs
@@ -17,13 +17,15 @@ use crate::skeleton;
 /// patterns for `length::Bag`.
 pub fn determine_coarse_hour_cycle(pattern: &Pattern) -> Option<CoarseHourCycle> {
     for item in pattern.items() {
-        if let PatternItem::Field(fields::Field { symbol, length: _ }) = item {
-            if let fields::FieldSymbol::Hour(pattern_hour) = symbol {
-                return Some(match pattern_hour {
-                    fields::Hour::H11 | fields::Hour::H12 => CoarseHourCycle::H11H12,
-                    fields::Hour::H23 | fields::Hour::H24 => CoarseHourCycle::H23H24,
-                });
-            }
+        if let PatternItem::Field(fields::Field {
+            symbol: fields::FieldSymbol::Hour(pattern_hour),
+            length: _,
+        }) = item
+        {
+            return Some(match pattern_hour {
+                fields::Hour::H11 | fields::Hour::H12 => CoarseHourCycle::H11H12,
+                fields::Hour::H23 | fields::Hour::H24 => CoarseHourCycle::H23H24,
+            });
         }
     }
 

From 36fd9561b6ebba038577ba5a4660e97806a75ec6 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Wed, 14 Jul 2021 15:42:06 -0500
Subject: [PATCH 14/17] Remove extraneous return

---
 components/datetime/src/provider/helpers.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/components/datetime/src/provider/helpers.rs b/components/datetime/src/provider/helpers.rs
index 59a743e5b35..6f29c14c48c 100644
--- a/components/datetime/src/provider/helpers.rs
+++ b/components/datetime/src/provider/helpers.rs
@@ -172,7 +172,6 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
                     }
                 }
             }
-            return Ok(pattern);
         }
 
         Ok(pattern)

From e7ee7e3b438b5745f221cec278d0c15096006e14 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Thu, 22 Jul 2021 08:51:59 -0500
Subject: [PATCH 15/17] Work around width expansion issue

---
 .../src/pattern/transform_hour_cycle.rs       |  3 +
 components/datetime/src/provider/helpers.rs   |  1 +
 components/datetime/src/skeleton.rs           | 76 +++++++++++++------
 provider/cldr/src/transform/dates/patterns.rs |  2 +-
 4 files changed, 57 insertions(+), 25 deletions(-)

diff --git a/components/datetime/src/pattern/transform_hour_cycle.rs b/components/datetime/src/pattern/transform_hour_cycle.rs
index 841888f6246..e98b6465007 100644
--- a/components/datetime/src/pattern/transform_hour_cycle.rs
+++ b/components/datetime/src/pattern/transform_hour_cycle.rs
@@ -76,6 +76,9 @@ pub fn apply_coarse_hour_cycle(
         &datetime.skeletons,
         &datetime.length_patterns,
         &skeleton.as_slice(),
+        // Prefer using the matched pattern directly, rather than mutating it to match the
+        // requested fields.
+        true,
     ) {
         skeleton::BestSkeleton::AllFieldsMatch(pattern)
         | skeleton::BestSkeleton::MissingOrExtraFields(pattern) => Some(format!("{}", pattern)),
diff --git a/components/datetime/src/provider/helpers.rs b/components/datetime/src/provider/helpers.rs
index 6f29c14c48c..f97262b1f71 100644
--- a/components/datetime/src/provider/helpers.rs
+++ b/components/datetime/src/provider/helpers.rs
@@ -75,6 +75,7 @@ impl DateTimePatterns for provider::gregory::DatePatternsV1 {
                 &self.datetime.skeletons,
                 &self.datetime.length_patterns,
                 &requested_fields,
+                false, // Prefer the requested fields over the matched pattern.
             ) {
                 skeleton::BestSkeleton::AllFieldsMatch(pattern)
                 | skeleton::BestSkeleton::MissingOrExtraFields(pattern) => Some(pattern),
diff --git a/components/datetime/src/skeleton.rs b/components/datetime/src/skeleton.rs
index fc588b2edb1..45f17ce5e8a 100644
--- a/components/datetime/src/skeleton.rs
+++ b/components/datetime/src/skeleton.rs
@@ -417,12 +417,25 @@ pub enum BestSkeleton<T> {
 // add a lifetime here. The pattern returned here could be one that we've already constructed in
 // the CLDR as an exotic type, or it could be one that was modified to meet the requirements of
 // the components bag.
+
+/// Given a set of fields (which represents a skeleton), try to create a best localized pattern
+// for those fields.
+///
+/// * `skeletons` - The skeletons that will be matched against
+/// * `length_patterns` - Contains information on how to combine date and time patterns.
+/// * `fields` - The desired fields to match against.
+/// * `prefer_matched_pattern` - This algorithm does some extra steps of trying to respect
+///         the desired fields, even if the provider data doesn't completely match. This
+///         configuration option makes it so that the final pattern won't have additional work
+///         done to mutate it to match the fields. It will prefer the actual matched pattern.
 pub fn create_best_pattern_for_fields<'a>(
     skeletons: &'a SkeletonsV1,
     length_patterns: &LengthPatternsV1,
     fields: &[Field],
+    prefer_matched_pattern: bool,
 ) -> BestSkeleton<Pattern> {
-    let first_pattern_match = get_best_available_format_pattern(skeletons, fields);
+    let first_pattern_match =
+        get_best_available_format_pattern(skeletons, fields, prefer_matched_pattern);
 
     // Try to match a skeleton to all of the fields.
     if let BestSkeleton::AllFieldsMatch(pattern) = first_pattern_match {
@@ -462,14 +475,14 @@ pub fn create_best_pattern_for_fields<'a>(
     // Match the date and time, and then simplify the combinatorial logic of the results into
     // an optional values of the results, and a boolean value.
     let (date_pattern, date_missing_or_extra) =
-        match get_best_available_format_pattern(skeletons, &date) {
+        match get_best_available_format_pattern(skeletons, &date, prefer_matched_pattern) {
             BestSkeleton::MissingOrExtraFields(fields) => (Some(fields), true),
             BestSkeleton::AllFieldsMatch(fields) => (Some(fields), false),
             BestSkeleton::NoMatch => (None, true),
         };
 
     let (time_pattern, time_missing_or_extra) =
-        match get_best_available_format_pattern(skeletons, &time) {
+        match get_best_available_format_pattern(skeletons, &time, prefer_matched_pattern) {
             BestSkeleton::MissingOrExtraFields(fields) => (Some(fields), true),
             BestSkeleton::AllFieldsMatch(fields) => (Some(fields), false),
             BestSkeleton::NoMatch => (None, true),
@@ -593,6 +606,7 @@ fn group_fields_by_type(fields: &[Field]) -> FieldsByType {
 pub fn get_best_available_format_pattern(
     skeletons: &SkeletonsV1,
     fields: &[Field],
+    prefer_matched_pattern: bool,
 ) -> BestSkeleton<Pattern> {
     let mut closest_format_pattern = None;
     let mut closest_distance: u32 = u32::MAX;
@@ -689,28 +703,37 @@ pub fn get_best_available_format_pattern(
     }
 
     // Modify the resulting pattern to have fields of the same length.
-    let expanded_pattern = Pattern::from(
-        closest_format_pattern
-            .items()
-            .iter()
-            .map(|item| {
-                if let PatternItem::Field(pattern_field) = item {
-                    if let Some(requested_field) = fields
-                        .iter()
-                        .find(|field| field.symbol == pattern_field.symbol)
-                    {
-                        if requested_field.length != pattern_field.length
-                            && requested_field.get_length_type() == pattern_field.get_length_type()
+    let expanded_pattern = if prefer_matched_pattern {
+        #[cfg(not(feature = "provider_transform_internals"))]
+        panic!("This code branch should only be run when transforming provider code.");
+
+        #[cfg(feature = "provider_transform_internals")]
+        closest_format_pattern.clone()
+    } else {
+        Pattern::from(
+            closest_format_pattern
+                .items()
+                .iter()
+                .map(|item| {
+                    if let PatternItem::Field(pattern_field) = item {
+                        if let Some(requested_field) = fields
+                            .iter()
+                            .find(|field| field.symbol == pattern_field.symbol)
                         {
-                            return PatternItem::Field(*requested_field);
+                            if requested_field.length != pattern_field.length
+                                && requested_field.get_length_type()
+                                    == pattern_field.get_length_type()
+                            {
+                                return PatternItem::Field(*requested_field);
+                            }
                         }
                     }
-                }
-                // There's no match, or this is a string literal return the original item.
-                item.clone()
-            })
-            .collect::<Vec<PatternItem>>(),
-    );
+                    // There's no match, or this is a string literal return the original item.
+                    item.clone()
+                })
+                .collect::<Vec<PatternItem>>(),
+        )
+    };
 
     if closest_distance >= SKELETON_EXTRA_SYMBOL {
         return BestSkeleton::MissingOrExtraFields(expanded_pattern);
@@ -777,6 +800,7 @@ mod test {
         match get_best_available_format_pattern(
             &data_provider.get().datetime.skeletons,
             &requested_fields,
+            false,
         ) {
             BestSkeleton::AllFieldsMatch(available_format_pattern)
             | BestSkeleton::MissingOrExtraFields(available_format_pattern) => {
@@ -804,6 +828,7 @@ mod test {
         match get_best_available_format_pattern(
             &data_provider.get().datetime.skeletons,
             &requested_fields,
+            false,
         ) {
             BestSkeleton::MissingOrExtraFields(available_format_pattern) => {
                 assert_eq!(available_format_pattern.to_string(), String::from("L"))
@@ -830,6 +855,7 @@ mod test {
             &data_provider.get().datetime.skeletons,
             &data_provider.get().datetime.length_patterns,
             &requested_fields,
+            false,
         ) {
             BestSkeleton::AllFieldsMatch(available_format_pattern) => {
                 // TODO - This needs to support the "Z" pattern. This test will begin to fail
@@ -852,7 +878,8 @@ mod test {
         assert_eq!(
             get_best_available_format_pattern(
                 &data_provider.get().datetime.skeletons,
-                &requested_fields
+                &requested_fields,
+                false
             ),
             BestSkeleton::NoMatch,
             "No match was found"
@@ -873,7 +900,8 @@ mod test {
         assert_eq!(
             get_best_available_format_pattern(
                 &data_provider.get().datetime.skeletons,
-                &requested_fields
+                &requested_fields,
+                false
             ),
             BestSkeleton::NoMatch,
             "No match was found"
diff --git a/provider/cldr/src/transform/dates/patterns.rs b/provider/cldr/src/transform/dates/patterns.rs
index 9cad7568c36..4091d5941c7 100644
--- a/provider/cldr/src/transform/dates/patterns.rs
+++ b/provider/cldr/src/transform/dates/patterns.rs
@@ -210,7 +210,7 @@ impl From<&cldr_json::Dates> for gregory::DatePatternsV1 {
                 if let Some(preferred_hour_cycle) = preferred_hour_cycle {
                     assert_eq!(
                         *hour_cycle, preferred_hour_cycle,
-                        "A locale contained a mix of flexible hour cycle types"
+                        "A locale contained a mix of coarse hour cycle types"
                     );
                 } else {
                     preferred_hour_cycle = Some(*hour_cycle);

From 816746ce07481dbe00c7b731e2adb4577eafb721 Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Fri, 23 Jul 2021 08:55:11 -0500
Subject: [PATCH 16/17] Update comment to be more general

---
 components/datetime/src/skeleton.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/components/datetime/src/skeleton.rs b/components/datetime/src/skeleton.rs
index 8cd66a37ed1..0fde5851fa2 100644
--- a/components/datetime/src/skeleton.rs
+++ b/components/datetime/src/skeleton.rs
@@ -474,10 +474,9 @@ pub fn create_best_pattern_for_fields<'a>(
         // TODO(#486) - Eras,
         // ... etc.
 
-        // TODO(#583) - Reviewer: this is commented out because TimeZone support is required
-        // here in order to generate length::Bag patterns correctly. For now I've commented out this
-        // line so that everything works for length::Bag with a preference, although it may lack
-        // a time zone.
+        // TODO(#583) - This is commented out because TimeZone support is required here in order to
+        // generate length::Bag patterns correctly. For now it's commented out so that everything
+        // works for length::Bag with a preference, although it may lack a time zone.
 
         // unimplemented!(
         //     "There are no \"other\" fields supported, these need to be appended to the pattern. {:?}", other

From 8e56e1034bef4cb509ea2386df29de5cd334307f Mon Sep 17 00:00:00 2001
From: Greg Tatum <tatum.creative@gmail.com>
Date: Wed, 28 Jul 2021 13:04:51 -0500
Subject: [PATCH 17/17] Add std as a feature requirement for
 provider_transform_internals

---
 components/datetime/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/datetime/Cargo.toml b/components/datetime/Cargo.toml
index 937438188d6..d35eaffe5fc 100644
--- a/components/datetime/Cargo.toml
+++ b/components/datetime/Cargo.toml
@@ -58,7 +58,7 @@ std = ["icu_provider/std", "icu_locid/std"]
 default = ["provider_serde"]
 bench = []
 provider_serde = ["serde", "litemap/serde"]
-provider_transform_internals = []
+provider_transform_internals = ["std"]
 
 [[bench]]
 name = "datetime"