Make errors Copy

src/builtins/core/calendar.rs

@@ -12,7 +12,6 @@ use crate::{
     parsers::parse_allowed_calendar_formats,
     TemporalError, TemporalResult,
 };
-use alloc::string::ToString;
 use core::str::FromStr;
 
 use icu_calendar::{
@@ -142,9 +141,9 @@ impl Calendar {
         // TODO: Determine the best way to handle "julian" here.
         // Not supported by `CalendarAlgorithm`
         let icu_locale_value = Value::try_from_utf8(&bytes.to_ascii_lowercase())
-            .map_err(|e| TemporalError::range().with_message(e.to_string()))?;
+            .map_err(|_| TemporalError::range().with_message("unknown calendar"))?;
         let algorithm = CalendarAlgorithm::try_from(&icu_locale_value)
-            .map_err(|e| TemporalError::range().with_message(e.to_string()))?;
+            .map_err(|_| TemporalError::range().with_message("unknown calendar"))?;
         let calendar_kind = match AnyCalendarKind::try_from(algorithm) {
             Ok(c) => c,
             // Handle `islamic` calendar idenitifier.
@@ -208,15 +207,12 @@ impl Calendar {
             );
         }
 
-        let calendar_date = self
-            .0
-            .from_codes(
-                resolved_fields.era_year.era.as_ref().map(|e| e.0.as_str()),
-                resolved_fields.era_year.year,
-                IcuMonthCode(resolved_fields.month_code.0),
-                resolved_fields.day,
-            )
-            .map_err(TemporalError::from_icu4x)?;
+        let calendar_date = self.0.from_codes(
+            resolved_fields.era_year.era.as_ref().map(|e| e.0.as_str()),
+            resolved_fields.era_year.year,
+            IcuMonthCode(resolved_fields.month_code.0),
+            resolved_fields.day,
+        )?;
         let iso = self.0.to_iso(&calendar_date);
         PlainDate::new_with_overflow(
             Iso.extended_year(&iso),
@@ -267,15 +263,12 @@ impl Calendar {
         }
 
         // We trust ResolvedCalendarFields to have calculated an appropriate reference year for us
-        let calendar_date = self
-            .0
-            .from_codes(
-                resolved_fields.era_year.era.as_ref().map(|e| e.0.as_str()),
-                resolved_fields.era_year.year,
-                IcuMonthCode(resolved_fields.month_code.0),
-                resolved_fields.day,
-            )
-            .map_err(TemporalError::from_icu4x)?;
+        let calendar_date = self.0.from_codes(
+            resolved_fields.era_year.era.as_ref().map(|e| e.0.as_str()),
+            resolved_fields.era_year.year,
+            IcuMonthCode(resolved_fields.month_code.0),
+            resolved_fields.day,
+        )?;
         let iso = self.0.to_iso(&calendar_date);
         PlainMonthDay::new_with_overflow(
             Iso.month(&iso).ordinal,
@@ -310,15 +303,12 @@ impl Calendar {
         }
 
         // NOTE: This might preemptively throw as `ICU4X` does not support regulating.
-        let calendar_date = self
-            .0
-            .from_codes(
-                resolved_fields.era_year.era.as_ref().map(|e| e.0.as_str()),
-                resolved_fields.era_year.year,
-                IcuMonthCode(resolved_fields.month_code.0),
-                resolved_fields.day,
-            )
-            .map_err(TemporalError::from_icu4x)?;
+        let calendar_date = self.0.from_codes(
+            resolved_fields.era_year.era.as_ref().map(|e| e.0.as_str()),
+            resolved_fields.era_year.year,
+            IcuMonthCode(resolved_fields.month_code.0),
+            resolved_fields.day,
+        )?;
         let iso = self.0.to_iso(&calendar_date);
         PlainYearMonth::new_with_overflow(
             Iso.year_info(&iso).year,

src/builtins/core/calendar/fields.rs

@@ -1,5 +1,3 @@
-use alloc::format;
-
 use tinystr::TinyAsciiStr;
 
 use super::types::month_to_month_code;
@@ -260,7 +258,7 @@ impl YearMonthCalendarFields {
                     .era()
                     .map(|t| TinyAsciiStr::<19>::try_from_utf8(t.as_bytes()))
                     .transpose()
-                    .map_err(|e| TemporalError::general(format!("{e}")))?,
+                    .map_err(|_| TemporalError::general("Invalid era"))?,
                 year_month.era_year(),
             )
         } else {

src/builtins/core/calendar/types.rs

@@ -3,8 +3,6 @@
 use tinystr::tinystr;
 use tinystr::TinyAsciiStr;
 
-use alloc::format;
-
 use crate::fields::CalendarFields;
 use crate::iso::{constrain_iso_day, is_valid_iso_day};
 use crate::options::ArithmeticOverflow;
@@ -162,10 +160,8 @@ impl EraYear {
                     return Err(TemporalError::range().with_message("Invalid era provided."));
                 };
                 if !era_info.range.contains(&era_year) {
-                    return Err(TemporalError::range().with_message(format!(
-                        "Year is not valid for the era {}",
-                        era_info.name.as_str()
-                    )));
+                    return Err(TemporalError::range()
+                        .with_message("Year is not valid for the provided era"));
                 }
                 let calculated_arith = era_info.arithmetic_year_for(era_year);
                 // or a RangeError exception if the fields are sufficient but their values are internally inconsistent
@@ -544,7 +540,7 @@ pub(crate) fn month_to_month_code(month: u8) -> TemporalResult<MonthCode> {
     let first = month / 10;
     let second = month % 10;
     let tinystr = TinyAsciiStr::<4>::try_from_raw([b'M', first + 48, second + 48, b'\0'])
-        .map_err(|e| TemporalError::range().with_message(format!("tinystr error {e}")))?;
+        .map_err(|_| TemporalError::range().with_message("Invalid month code"))?;
     Ok(MonthCode(tinystr))
 }
 

src/builtins/core/date.rs

@@ -18,7 +18,7 @@ use crate::{
     provider::{NeverProvider, TimeZoneProvider},
     MonthCode, TemporalError, TemporalResult, TimeZone,
 };
-use alloc::{format, string::String};
+use alloc::string::String;
 use core::{cmp::Ordering, str::FromStr};
 use icu_calendar::AnyCalendarKind;
 use writeable::Writeable;
@@ -620,7 +620,7 @@ impl PlainDate {
             .era()
             .map(|e| {
                 TinyAsciiStr::<19>::try_from_utf8(e.as_bytes())
-                    .map_err(|e| TemporalError::general(format!("{e}")))
+                    .map_err(|_| TemporalError::general("Parsing era failed"))
             })
             .transpose()?;
         let fields = YearMonthCalendarFields::new()

src/builtins/core/duration.rs

@@ -13,7 +13,6 @@ use crate::{
     provider::TimeZoneProvider,
     temporal_assert, Sign, TemporalError, TemporalResult, NS_PER_DAY,
 };
-use alloc::format;
 use alloc::string::String;
 use core::{cmp::Ordering, str::FromStr};
 use ixdtf::{
@@ -695,9 +694,7 @@ impl Duration {
 
     // Converts a UTF-8 encoded string into a `Duration`.
     pub fn from_utf8(s: &[u8]) -> TemporalResult<Self> {
-        let parse_record = IsoDurationParser::<Utf8>::from_utf8(s)
-            .parse()
-            .map_err(|e| TemporalError::range().with_message(format!("{e}")))?;
+        let parse_record = IsoDurationParser::<Utf8>::from_utf8(s).parse()?;
 
         fn fraction_to_unadjusted_ns(fraction: Option<Fraction>) -> Result<u32, TemporalError> {
             if let Some(fraction) = fraction {

src/builtins/core/timezone.rs

@@ -1,6 +1,6 @@
 //! This module implements the Temporal `TimeZone` and components.
 
-use alloc::string::{String, ToString};
+use alloc::string::String;
 
 use ixdtf::encoding::Utf8;
 use ixdtf::{
@@ -76,9 +76,7 @@ impl UtcOffset {
     }
 
     pub fn from_utf8(source: &[u8]) -> TemporalResult<Self> {
-        let record = TimeZoneParser::from_utf8(source)
-            .parse_offset()
-            .map_err(|e| TemporalError::range().with_message(e.to_string()))?;
+        let record = TimeZoneParser::from_utf8(source).parse_offset()?;
         Self::from_ixdtf_record(record)
     }