Next round of try_from_str et al. (#5085)

#4931

Covers all types that had a `try_from_bytes`.

There are still a lot of types that implement `FromStr`, but don't have
any inherent methods. Those will be next.

components/calendar/src/any_calendar.rs

@@ -1017,12 +1017,10 @@ impl AnyCalendarKind {
             AnyCalendarKind::Gregorian => value!("gregory"),
             AnyCalendarKind::Hebrew => value!("hebrew"),
             AnyCalendarKind::Indian => value!("indian"),
-            AnyCalendarKind::IslamicCivil => Value::try_from_bytes(b"islamic-civil").unwrap(),
+            AnyCalendarKind::IslamicCivil => Value::try_from_str("islamic-civil").unwrap(),
             AnyCalendarKind::IslamicObservational => value!("islamic"),
-            AnyCalendarKind::IslamicTabular => Value::try_from_bytes(b"islamic-tbla").unwrap(),
-            AnyCalendarKind::IslamicUmmAlQura => {
-                Value::try_from_bytes(b"islamic-umalqura").unwrap()
-            }
+            AnyCalendarKind::IslamicTabular => Value::try_from_str("islamic-tbla").unwrap(),
+            AnyCalendarKind::IslamicUmmAlQura => Value::try_from_str("islamic-umalqura").unwrap(),
             AnyCalendarKind::Iso => value!("iso"),
             AnyCalendarKind::Japanese => value!("japanese"),
             AnyCalendarKind::JapaneseExtended => value!("japanext"),

components/datetime/src/any/zoned_datetime.rs

@@ -155,7 +155,6 @@ impl ZonedDateTimeFormatter {
     /// use icu::datetime::ZonedDateTimeFormatter;
     /// use icu::locale::locale;
     /// use icu::timezone::CustomTimeZone;
-    /// use std::str::FromStr;
     /// use writeable::assert_writeable_eq;
     ///
     /// let mut options = components::Bag::default();
@@ -174,7 +173,7 @@ impl ZonedDateTimeFormatter {
     ///
     /// let datetime =
     ///     DateTime::try_new_iso_datetime(2021, 04, 08, 16, 12, 37).unwrap();
-    /// let time_zone = CustomTimeZone::from_str("-07:00").unwrap();
+    /// let time_zone = CustomTimeZone::try_from_str("-07:00").unwrap();
     /// let any_datetime = datetime.to_any();
     ///
     /// assert_writeable_eq!(
@@ -330,7 +329,6 @@ impl ZonedDateTimeFormatter {
     /// use icu::datetime::ZonedDateTimeFormatter;
     /// use icu::locale::locale;
     /// use icu::timezone::CustomTimeZone;
-    /// use std::str::FromStr;
     /// use writeable::assert_writeable_eq;
     ///
     /// let options = length::Bag::from_date_time_style(
@@ -348,7 +346,7 @@ impl ZonedDateTimeFormatter {
     ///
     /// let datetime =
     ///     DateTime::try_new_iso_datetime(2021, 04, 08, 16, 12, 37).unwrap();
-    /// let time_zone = CustomTimeZone::from_str("-07:00").unwrap();
+    /// let time_zone = CustomTimeZone::try_from_str("-07:00").unwrap();
     /// let any_datetime = datetime.to_any();
     ///
     /// assert_writeable_eq!(
@@ -576,7 +574,6 @@ fn buffer_constructor() {
     use icu::datetime::ZonedDateTimeFormatter;
     use icu::locale::locale;
     use icu::timezone::CustomTimeZone;
-    use std::str::FromStr;
     use writeable::assert_writeable_eq;
 
     let provider = icu_provider_blob::BlobDataProvider::try_new_from_static_blob(include_bytes!(
@@ -597,7 +594,7 @@ fn buffer_constructor() {
             &DateTime::try_new_iso_datetime(2021, 04, 08, 16, 12, 37)
                 .unwrap()
                 .to_any(),
-            &CustomTimeZone::from_str("-07:00").unwrap()
+            &CustomTimeZone::try_from_str("-07:00").unwrap()
         )
         .unwrap(),
         "Apr 8, 2021, 4:12:37 PM GMT-07:00"

components/datetime/src/lib.rs

@@ -36,7 +36,6 @@
 //!     TypedDateTimeFormatter,
 //! };
 //! use icu::locale::{locale, Locale};
-//! use std::str::FromStr;
 //! use writeable::assert_writeable_eq;
 //!
 //! // See the next code example for a more ergonomic example with .into().
@@ -47,7 +46,7 @@
 //!     ));
 //!
 //! // You can work with a formatter that can select the calendar at runtime:
-//! let locale = Locale::from_str("en-u-ca-gregory").unwrap();
+//! let locale = Locale::try_from_str("en-u-ca-gregory").unwrap();
 //! let dtf = DateTimeFormatter::try_new(&locale.into(), options.clone())
 //!     .expect("Failed to create DateTimeFormatter instance.");
 //!

components/datetime/src/zoned_datetime.rs

@@ -54,7 +54,6 @@ use crate::{
 /// use icu::datetime::{options::length, TypedZonedDateTimeFormatter};
 /// use icu::locale::locale;
 /// use icu::timezone::CustomTimeZone;
-/// use std::str::FromStr;
 /// use writeable::assert_writeable_eq;
 ///
 /// let options = length::Bag::from_date_time_style(
@@ -70,7 +69,7 @@ use crate::{
 ///
 /// let datetime =
 ///     DateTime::try_new_gregorian_datetime(2020, 9, 12, 12, 34, 28).unwrap();
-/// let time_zone = CustomTimeZone::from_str("-07:00").unwrap();
+/// let time_zone = CustomTimeZone::try_from_str("-07:00").unwrap();
 ///
 /// let formatted_date = zdtf.format(&datetime, &time_zone);
 ///
@@ -368,7 +367,6 @@ impl<C: CldrCalendar> TypedZonedDateTimeFormatter<C> {
     /// use icu::datetime::{options::length, TypedZonedDateTimeFormatter};
     /// use icu::locale::locale;
     /// use icu::timezone::CustomTimeZone;
-    /// use std::str::FromStr;
     /// use writeable::assert_writeable_eq;
     ///
     /// let options = length::Bag::from_date_time_style(
@@ -385,7 +383,7 @@ impl<C: CldrCalendar> TypedZonedDateTimeFormatter<C> {
     ///
     /// let datetime =
     ///     DateTime::try_new_gregorian_datetime(2020, 9, 12, 12, 34, 28).unwrap();
-    /// let time_zone = CustomTimeZone::from_str("-07:00").unwrap();
+    /// let time_zone = CustomTimeZone::try_from_str("-07:00").unwrap();
     ///
     /// let formatted_date = zdtf.format(&datetime, &time_zone);
     ///
@@ -409,7 +407,6 @@ impl<C: CldrCalendar> TypedZonedDateTimeFormatter<C> {
     /// use icu::datetime::{options::length, TypedZonedDateTimeFormatter};
     /// use icu::locale::locale;
     /// use icu::timezone::CustomTimeZone;
-    /// use std::str::FromStr;
     ///
     /// let options = length::Bag::from_date_time_style(
     ///     length::Date::Medium,
@@ -425,7 +422,7 @@ impl<C: CldrCalendar> TypedZonedDateTimeFormatter<C> {
     ///
     /// let datetime =
     ///     DateTime::try_new_gregorian_datetime(2020, 9, 12, 12, 34, 28).unwrap();
-    /// let time_zone = CustomTimeZone::from_str("-07:00").unwrap();
+    /// let time_zone = CustomTimeZone::try_from_str("-07:00").unwrap();
     ///
     /// let formatted_string = zdtf.format_to_string(&datetime, &time_zone);
     ///

components/datetime/tests/datetime.rs

@@ -49,7 +49,6 @@ use patterns::{
     dayperiods::{DayPeriodExpectation, DayPeriodTests},
     time_zones::{TimeZoneConfig, TimeZoneExpectation, TimeZoneTests},
 };
-use std::str::FromStr;
 use tinystr::tinystr;
 use writeable::assert_writeable_eq;
 
@@ -98,7 +97,8 @@ fn test_fixture(fixture_name: &str, file: &str) {
             None => format!("\n  file: {fixture_name}.json\n"),
         };
         for (locale, output_value) in fx.output.values {
-            let locale = Locale::from_str(&locale).expect("Expected parseable locale in fixture");
+            let locale =
+                Locale::try_from_str(&locale).expect("Expected parseable locale in fixture");
             if let Some(kind) = AnyCalendarKind::get_for_locale(&locale) {
                 match kind {
                     AnyCalendarKind::Buddhist => assert_fixture_element(

components/experimental/src/transliterate/transliterator/replaceable.rs

@@ -723,25 +723,25 @@ impl<'a, 'b> Insertable<'a, 'b> {
     /// Push a `&str` on the replacement.
     pub(crate) fn push_str(&mut self, s: &str) {
         // SAFETY: s is valid UTF-8 by type
-        unsafe { self.push_bytes(s.as_bytes()) };
+        unsafe { self.push_utf8(s.as_bytes()) };
         debug_assert!(self.curr <= self.end());
     }
 
     /// # Safety
-    /// The caller must ensure that `bytes` is valid UTF-8.
-    unsafe fn push_bytes(&mut self, bytes: &[u8]) {
-        if self.free_range().len() >= bytes.len() {
+    /// The caller must ensure that `code_units` is valid UTF-8.
+    unsafe fn push_utf8(&mut self, code_units: &[u8]) {
+        if self.free_range().len() >= code_units.len() {
             // SAFETY: The caller guarantees these are valid UTF-8
-            self._rep.content[self.curr..self.curr + bytes.len()].copy_from_slice(bytes);
-            self.curr += bytes.len();
+            self._rep.content[self.curr..self.curr + code_units.len()].copy_from_slice(code_units);
+            self.curr += code_units.len();
             return;
         }
         // eprintln!("WARNING: free space not sufficient for Insertable::push_bytes");
 
         // SAFETY: The caller guarantees these are valid UTF-8
         self._rep
             .content
-            .splice(self.free_range(), bytes.iter().copied());
+            .splice(self.free_range(), code_units.iter().copied());
         // SAFETY: The free range did not have enough space. The above splice replaces the completey
         // remaining free range with the replacement, so there are no more un-replaced bytes left
         // in the replacement range.

components/experimental/src/units/measureunit.rs

@@ -33,7 +33,7 @@ impl<'data> MeasureUnitParser<'data> {
     /// NOTE:
     ///    if the unit id is found, the function will return (unit id, part without the unit id and without `-` at the beginning of the remaining part if it exists).
     ///    if the unit id is not found, the function will return an error.
-    fn get_unit_id<'a>(&'a self, part: &'a [u8]) -> Result<(u16, &[u8]), InvalidUnitError> {
+    fn get_unit_id<'a>(&self, part: &'a [u8]) -> Result<(u16, &'a [u8]), InvalidUnitError> {
         let mut cursor = self.units_trie.cursor();
         let mut longest_match = Err(InvalidUnitError);
 
@@ -49,7 +49,7 @@ impl<'data> MeasureUnitParser<'data> {
         longest_match
     }
 
-    fn get_power<'a>(&'a self, part: &'a [u8]) -> Result<(u8, &[u8]), InvalidUnitError> {
+    fn get_power<'a>(&self, part: &'a [u8]) -> Result<(u8, &'a [u8]), InvalidUnitError> {
         let (power, part_without_power) = get_power(part);
 
         // If the power is not found, return the part as it is.
@@ -67,7 +67,7 @@ impl<'data> MeasureUnitParser<'data> {
     /// Get the SI prefix.
     /// NOTE:
     ///    if the prefix is not found, the function will return (SiPrefix { power: 0, base: Base::Decimal }, part).
-    fn get_si_prefix<'a>(&'a self, part: &'a [u8]) -> (SiPrefix, &[u8]) {
+    fn get_si_prefix<'a>(&self, part: &'a [u8]) -> (SiPrefix, &'a [u8]) {
         let (si_prefix, part_without_si_prefix) = get_si_prefix(part);
         if part_without_si_prefix.len() == part.len() {
             return (si_prefix, part);
@@ -85,17 +85,22 @@ impl<'data> MeasureUnitParser<'data> {
     /// Returns:
     ///    - Ok(MeasureUnit) if the identifier is valid.
     ///    - Err(InvalidUnitError) if the identifier is invalid.
-    pub fn try_from_bytes(&self, identifier: &'data [u8]) -> Result<MeasureUnit, InvalidUnitError> {
-        if identifier.starts_with(b"-") || identifier.ends_with(b"-") {
+    #[inline]
+    pub fn try_from_str(&self, s: &str) -> Result<MeasureUnit, InvalidUnitError> {
+        self.try_from_utf8(s.as_bytes())
+    }
+
+    /// See [`Self::try_from_str`]
+    pub fn try_from_utf8(&self, mut code_units: &[u8]) -> Result<MeasureUnit, InvalidUnitError> {
+        if code_units.starts_with(b"-") || code_units.ends_with(b"-") {
             return Err(InvalidUnitError);
         }
 
         let mut measure_unit_items = Vec::<MeasureUnitItem>::new();
-        let mut identifier = identifier;
         let mut sign = 1;
-        while !identifier.is_empty() {
+        while !code_units.is_empty() {
             // First: extract the power.
-            let (power, identifier_part_without_power) = self.get_power(identifier)?;
+            let (power, identifier_part_without_power) = self.get_power(code_units)?;
 
             // Second: extract the si_prefix and the unit_id.
             let (si_prefix, unit_id, identifier_part_without_unit_id) =
@@ -118,9 +123,9 @@ impl<'data> MeasureUnitParser<'data> {
                                 }
                                 // If the sign is negative, this means that the identifier may contain more than one `per-` keyword.
                                 Err(_) if sign == 1 => {
-                                    if let Some(remainder) = identifier.strip_prefix(b"per-") {
+                                    if let Some(remainder) = code_units.strip_prefix(b"per-") {
                                         sign = -1;
-                                        identifier = remainder;
+                                        code_units = remainder;
                                         continue;
                                     }
 
@@ -138,7 +143,7 @@ impl<'data> MeasureUnitParser<'data> {
                 unit_id,
             });
 
-            identifier = match identifier_part_without_unit_id.strip_prefix(b"-") {
+            code_units = match identifier_part_without_unit_id.strip_prefix(b"-") {
                 Some(remainder) => remainder,
                 None if identifier_part_without_unit_id.is_empty() => {
                     identifier_part_without_unit_id

components/experimental/tests/units/units_test.rs

@@ -42,10 +42,10 @@ fn test_cldr_unit_tests() {
 
     for test in tests {
         let input_unit = parser
-            .try_from_bytes(test.input_unit.as_bytes())
+            .try_from_str(&test.input_unit)
             .expect("Failed to parse input unit");
         let output_unit = parser
-            .try_from_bytes(test.output_unit.as_bytes())
+            .try_from_str(&test.output_unit)
             .expect("Failed to parse output unit");
 
         let converter: UnitsConverter<Ratio<BigInt>> = converter_factory
@@ -211,10 +211,10 @@ fn test_units_non_convertible() {
 
     for (input, output) in non_convertible_units.iter() {
         let input_unit = parser
-            .try_from_bytes(input.as_bytes())
+            .try_from_str(input)
             .expect("Failed to parse input unit");
         let output_unit = parser
-            .try_from_bytes(output.as_bytes())
+            .try_from_str(output)
             .expect("Failed to parse output unit");
 
         let result: Option<UnitsConverter<f64>> =
@@ -290,7 +290,7 @@ fn test_unparsable_units() {
 
     unparsable_units.iter().for_each(|unit| {
         assert!(
-            parser.try_from_bytes(unit.as_bytes()).is_err(),
+            parser.try_from_str(unit).is_err(),
             "Unit '{}' should be unparsable but was parsed successfully.",
             unit
         );

components/icu/examples/tui.rs

@@ -15,7 +15,6 @@ use icu::plurals::{PluralCategory, PluralRules};
 use icu::timezone::CustomTimeZone;
 use icu_collections::codepointinvlist::CodePointInversionListBuilder;
 use std::env;
-use std::str::FromStr;
 
 fn print<T: AsRef<str>>(_input: T) {
     #[cfg(debug_assertions)]
@@ -53,7 +52,7 @@ fn main(_argc: isize, _argv: *const *const u8) -> isize {
         )
         .expect("Failed to create TypedDateTimeFormatter.");
         let today_date = DateTime::try_new_gregorian_datetime(2020, 10, 10, 18, 56, 0).unwrap();
-        let today_tz = CustomTimeZone::from_str("Z").unwrap(); // Z refers to the utc timezone
+        let today_tz = CustomTimeZone::try_from_str("Z").unwrap(); // Z refers to the utc timezone
 
         let formatted_dt = dtf.format(&today_date, &today_tz);