Perform UTF-8 <-> UTF-16 conversions in Rust google#8

Author: bdragon

rust_icu_common/src/lib.rs

@@ -146,6 +146,12 @@ impl From<std::string::FromUtf8Error> for Error {
     }
 }
 
+impl From<std::string::FromUtf16Error> for Error {
+    fn from(e: std::string::FromUtf16Error) -> Self {
+        Self::wrapper(e)
+    }
+}
+
 impl Into<std::fmt::Error> for Error {
     fn into(self) -> std::fmt::Error {
         // It is not possible to transfer any info into std::fmt::Error, so we log instead.
@@ -333,7 +339,7 @@ macro_rules! format_ustring_for_type{
             let result = paste::item! {
                 self. [< $method_name _ustring>] (number)?
             };
-            String::try_from(&result)
+            String::try_from(&result).map_err(|e| e.into())
         }
 
         // Should be able to use https://github.com/google/rust_icu/pull/144 to

rust_icu_intl/src/lib.rs

@@ -55,7 +55,6 @@
 use rust_icu_uloc as uloc;
 use rust_icu_umsg::{self as umsg, message_format};
 use rust_icu_ustring as ustring;
-use std::convert::TryFrom;
 
 /// Implements ECMA-402 `Intl.PluralRules` based on the ICU locale data.
 pub struct PluralRules {
@@ -75,7 +74,7 @@ other {other}}"#;
 impl PluralRules {
     /// Creates a new plural rules formatter.
     pub fn new(locale: &uloc::ULoc) -> PluralRules {
-        let pattern = ustring::UChar::try_from(RESPONSES).expect("pattern should never fail");
+        let pattern = ustring::UChar::from(RESPONSES);
         let formatter = umsg::UMessageFormat::try_from(&pattern, &locale)
             .expect("this formatter should never fail");
         PluralRules { formatter }
@@ -101,6 +100,7 @@ impl PluralRules {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::convert::TryFrom;
 
     // Checks the rule and prints useful diagnostic messages in case of failure.
     fn check_rule(expected: &str, n: f64, rules: &PluralRules) {

rust_icu_ubrk/src/lib.rs

@@ -163,7 +163,7 @@ impl UBreakIterator {
         locale: &str,
         text: &str,
     ) -> Result<Self, common::Error> {
-        let text = ustring::UChar::try_from(text)?;
+        let text = ustring::UChar::from(text);
         let locale = uloc::ULoc::try_from(locale)?;
         Self::try_new_ustring(type_, &locale, &text)
     }
@@ -209,8 +209,8 @@ impl UBreakIterator {
         rules: &str,
         text: &str,
     ) -> Result<Self, common::Error> {
-        let rules = ustring::UChar::try_from(rules)?;
-        let text = ustring::UChar::try_from(text)?;
+        let rules = ustring::UChar::from(rules);
+        let text = ustring::UChar::from(text);
         Self::try_new_rules_ustring(&rules, &text)
     }
 
@@ -258,7 +258,7 @@ impl UBreakIterator {
         rules: &Vec<u8>,
         text: &str,
     ) -> Result<Self, common::Error> {
-        let text = ustring::UChar::try_from(text)?;
+        let text = ustring::UChar::from(text);
         Self::try_new_binary_rules_ustring(rules, &text)
     }
 
@@ -364,7 +364,7 @@ impl UBreakIterator {
     ///
     /// Implements `ubrk_setText`.
     pub fn set_text(&mut self, text: &str) -> Result<(), common::Error> {
-        let text = ustring::UChar::try_from(text)?;
+        let text = ustring::UChar::from(text);
         self.set_text_ustring(&text)
     }
 

rust_icu_ucal/src/lib.rs

@@ -83,7 +83,7 @@ impl UCalendar {
         locale: &str,
         cal_type: sys::UCalendarType,
     ) -> Result<UCalendar, common::Error> {
-        let zone_id_uchar = ustring::UChar::try_from(zone_id)?;
+        let zone_id_uchar = ustring::UChar::from(zone_id);
         Self::new_from_uchar(&zone_id_uchar, locale, cal_type)
     }
     /// Returns this UCalendar's internal C representation.  Use only for interfacing with the C
@@ -206,7 +206,7 @@ impl UCalendar {
 /// Implements `ucal_setDefaultTimeZone`
 pub fn set_default_time_zone(zone_id: &str) -> Result<(), common::Error> {
     let mut status = common::Error::OK_CODE;
-    let mut zone_id_uchar = ustring::UChar::try_from(zone_id)?;
+    let mut zone_id_uchar = ustring::UChar::from(zone_id);
     zone_id_uchar.make_z();
     // Requires zone_id_uchar to be a valid pointer until the function returns.
     unsafe {
@@ -243,7 +243,7 @@ pub fn get_default_time_zone() -> Result<String, common::Error> {
     };
     common::Error::ok_or_warning(status)?;
     trace!("result: {:?}", uchar);
-    String::try_from(&uchar)
+    String::try_from(&uchar).map_err(|e| e.into())
 }
 
 /// Implements `ucal_getTZDataVersion`

rust_icu_ucol/src/lib.rs

@@ -44,8 +44,8 @@
 //! let collator = ucol::UCollator::try_from("sr-Latn").expect("collator");
 //! let mut mixed_up = vec!["d", "dž", "đ", "a", "b", "c", "č", "ć"];
 //! mixed_up.sort_by(|a, b| {
-//!    let first = ustring::UChar::try_from(*a).expect("first");
-//!    let second = ustring::UChar::try_from(*b).expect("second");
+//!    let first = ustring::UChar::from(*a);
+//!    let second = ustring::UChar::from(*b);
 //!    collator.strcoll(&first, &second)
 //! });
 //! let alphabet = vec!["a", "b", "c", "č", "ć", "d", "dž", "đ"];
@@ -254,8 +254,8 @@ mod tests {
         let collator = crate::UCollator::try_from("sr-Latn")?;
         let mut mixed_up = vec!["d", "dž", "đ", "a", "b", "c", "č", "ć"];
         mixed_up.sort_by(|a, b| {
-            let first = ustring::UChar::try_from(*a).expect("first");
-            let second = ustring::UChar::try_from(*b).expect("second");
+            let first = ustring::UChar::from(*a);
+            let second = ustring::UChar::from(*b);
             collator.strcoll(&first, &second)
         });
 

rust_icu_udat/src/lib.rs

@@ -86,7 +86,7 @@ impl UDateFormat {
             "programmer error: date_style may not be UDAT_PATTERN"
         );
         // pattern is ignored if time_style or date_style aren't equal to pattern.
-        let pattern = ustring::UChar::try_from("").expect("pattern created");
+        let pattern = ustring::UChar::from("");
 
         Self::new_internal(time_style, date_style, loc, tz_id, &pattern)
     }
@@ -158,7 +158,7 @@ impl UDateFormat {
     ///
     /// Implements `udat_parse`
     pub fn parse(&self, datetime: &str) -> Result<sys::UDate, common::Error> {
-        let datetime_uc = ustring::UChar::try_from(datetime)?;
+        let datetime_uc = ustring::UChar::from(datetime);
         self.parse_from_position(&datetime_uc, 0).map(|r| r.date)
     }
 
@@ -243,7 +243,7 @@ impl UDateFormat {
             };
             common::Error::ok_or_warning(status)?;
         }
-        String::try_from(&result)
+        String::try_from(&result).map_err(|e| e.into())
     }
 }
 
@@ -340,7 +340,7 @@ mod tests {
         ];
         for t in tests {
             let loc = uloc::ULoc::try_from(t.locale)?;
-            let tz_id = ustring::UChar::try_from(t.timezone)?;
+            let tz_id = ustring::UChar::from(t.timezone);
 
             let mut fmt = UDateFormat::new_with_styles(
                 sys::UDateFormatStyle::UDAT_FULL,
@@ -385,9 +385,9 @@ mod tests {
             },
         ];
         let loc = uloc::ULoc::try_from("en-US")?;
-        let tz_id = ustring::UChar::try_from("America/New_York")?;
+        let tz_id = ustring::UChar::from("America/New_York");
         for t in tests {
-            let pattern = ustring::UChar::try_from(t.pattern)?;
+            let pattern = ustring::UChar::from(t.pattern);
             let fmt = UDateFormat::new_with_pattern(&loc, &tz_id, &pattern)?;
             let actual = fmt.format(t.date)?;
             assert_eq!(
@@ -422,10 +422,10 @@ mod tests {
         ];
 
         let loc = uloc::ULoc::try_from("en-US")?;
-        let tz_id = ustring::UChar::try_from("America/New_York")?;
+        let tz_id = ustring::UChar::from("America/New_York");
 
         for test in tests {
-            let pattern = ustring::UChar::try_from(test.pattern)?;
+            let pattern = ustring::UChar::from(test.pattern);
             let format = UDateFormat::new_with_pattern(&loc, &tz_id, &pattern)?;
             let actual = format.parse(test.input)?;
             assert_eq!(

rust_icu_uformattable/src/lib.rs

@@ -165,7 +165,7 @@ impl<'a> crate::UFormattable<'a> {
     /// Implements `ufmt_getUChars`
     pub fn get_str(&self) -> Result<String, common::Error> {
         let ustr = self.get_ustring()?;
-        String::try_from(&ustr)
+        String::try_from(&ustr).map_err(|e| e.into())
     }
 
     /// Use [UFormattable::get_type] to ensure that this formattable is an array before using this

rust_icu_ulistformatter/src/lib.rs

@@ -95,7 +95,7 @@ impl UListFormatter {
     /// Implements `ulistfmt_format`.
     pub fn format(&self, list: &[&str]) -> Result<String, common::Error> {
         let result = self.format_uchar(list)?;
-        String::try_from(&result)
+        String::try_from(&result).map_err(|e| e.into())
     }
 
     /// Implements `ulistfmt_format`.
@@ -179,7 +179,7 @@ where
     fn try_from(list: &[T]) -> Result<Self, Self::Error> {
         let mut elements: Vec<ustring::UChar> = Vec::with_capacity(list.len());
         for element in list {
-            let uchar = ustring::UChar::try_from(element.as_ref())?;
+            let uchar = ustring::UChar::from(element.as_ref());
             elements.push(uchar);
         }
         let pointers = elements.iter().map(|e| e.as_c_ptr()).collect();