Provide details when displaying component errors

Author: jhpratt

src/date.rs

@@ -990,13 +990,17 @@ impl Date {
 
  // Verification for all components is done at parse time.
  match items {
- items!(year, month, day) => Ok(internals::Date::from_ymd_unchecked(year, month.get(), day.get())),
- items!(year, ordinal_day) => Ok(internals::Date::from_yo_unchecked(year, ordinal_day.get())),
- items!(week_based_year, iso_week, weekday) => Ok(internals::Date::from_iso_ywd_unchecked(
- week_based_year,
- iso_week.get(),
- weekday,
+ items!(year, month, day) => Ok(internals::Date::from_ymd_unchecked(
+ year,
+ month.get(),
+ day.get(),
  )),
+ items!(year, ordinal_day) => {
+ Ok(internals::Date::from_yo_unchecked(year, ordinal_day.get()))
+ }
+ items!(week_based_year, iso_week, weekday) => Ok(
+ internals::Date::from_iso_ywd_unchecked(week_based_year, iso_week.get(), weekday),
+ ),
  items!(year, sunday_week, weekday) => Ok(internals::Date::from_yo_unchecked(
  year,
  #[allow(clippy::cast_sign_loss)]

src/error.rs

@@ -1,16 +1,20 @@
 use crate::format::ParseError;
+#[cfg(not(feature = "std"))]
+use crate::no_std_prelude::*;
 use core::fmt;
 
 /// A unified error type for anything returned by a method in the time crate.
 ///
 /// This can be used when you either don't know or don't care about the exact
 /// error returned. `Result<_, time::Error>` will work in these situations.
+// Boxing the `ComponentRangeError` reduces the size of `Error` from 72 bytes to
+// 16.
 #[allow(clippy::missing_docs_in_private_items)] // variants only
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Error {
  ConversionRange(ConversionRangeError),
- ComponentRange(ComponentRangeError),
+ ComponentRange(Box<ComponentRangeError>),
  Parse(ParseError),
 }
 
@@ -53,22 +57,49 @@ impl From<ConversionRangeError> for Error {
 
 /// An error type indicating that a component provided to a method was out of
 /// range, causing a failure.
+// i64 is the narrowest type fitting all use cases. This eliminates the need
+// for a type parameter.
 #[allow(missing_copy_implementations)] // Non-copy fields may be added.
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ComponentRangeError;
+pub struct ComponentRangeError {
+ /// Name of the component.
+ pub(crate) name: &'static str,
+ /// Minimum allowed value, inclusive.
+ pub(crate) minimum: i64,
+ /// Maximum allowed value, inclusive.
+ pub(crate) maximum: i64,
+ /// Value that was provided.
+ pub(crate) value: i64,
+ /// The minimum and/or maximum is only valid with the following values.
+ pub(crate) given: Vec<(&'static str, i64)>,
+}
 
 impl fmt::Display for ComponentRangeError {
  #[inline(always)]
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.write_str("A component's value is out of range")
+ write!(
+ f,
+ "{} must be in the range {}..={}",
+ self.name, self.minimum, self.maximum
+ )?;
+
+ let mut iter = self.given.iter();
+ if let Some((name, value)) = iter.next() {
+ write!(f, " given {}={}", name, value)?;
+ for (name, value) in iter {
+ write!(f, ", {}={}", name, value)?;
+ }
+ }
+
+ write!(f, " (was {})", self.value)
  }
 }
 
 impl From<ComponentRangeError> for Error {
  #[inline(always)]
  fn from(original: ComponentRangeError) -> Self {
- Self::ComponentRange(original)
+ Self::ComponentRange(Box::new(original))
  }
 }
 

src/internals.rs

@@ -64,7 +64,10 @@ impl Date {
  #[inline]
  pub(crate) fn from_iso_ywd_unchecked(year: i32, week: u8, weekday: Weekday) -> crate::Date {
  let ordinal = week as u16 * 7 + weekday.iso_weekday_number() as u16
- - (Self::from_yo_unchecked(year, 4).weekday().iso_weekday_number() as u16 + 3);
+ - (Self::from_yo_unchecked(year, 4)
+ .weekday()
+ .iso_weekday_number() as u16
+ + 3);
 
  if ordinal < 1 {
  return Self::from_yo_unchecked(year - 1, ordinal + days_in_year(year - 1));

src/lib.rs

@@ -139,7 +139,6 @@
 )]
 #![warn(
  unused_extern_crates,
- box_pointers,
  missing_copy_implementations,
  missing_debug_implementations,
  single_use_lifetimes,
@@ -200,17 +199,6 @@ macro_rules! assert_value_in_range {
  }
  };
 
- ($value:ident in $start:expr => exclusive $end:expr) => {
- if !($start..$end).contains(&$value) {
- panic!(
- concat!(stringify!($value), " must be in the range {}..{} (was {})"),
- $start,
- $end,
- $value,
- );
- }
- };
-
  ($value:ident in $start:expr => $end:expr, given $($conditional:ident),+ $(,)?) => {
  if !($start..=$end).contains(&$value) {
  panic!(
@@ -224,23 +212,30 @@ macro_rules! assert_value_in_range {
  };
 }
 
+// TODO Some of the formatting can likely be performed at compile-time.
 /// Returns `None` if the value is not in range.
 macro_rules! ensure_value_in_range {
  ($value:ident in $start:expr => $end:expr) => {
  if !($start..=$end).contains(&$value) {
- return Err(ComponentRangeError);
- }
- };
-
- ($value:ident in $start:expr => exclusive $end:expr) => {
- if !($start..$end).contains(&$value) {
- return Err(ComponentRangeError);
+ return Err(ComponentRangeError {
+  name: stringify!($value),
+  minimum: i64::from($start),
+ maximum: i64::from($end),
+  value: i64::from($value),
+  given: Vec::new(),
+ });
  }
  };
 
- ($value:ident in $start:expr => $end:expr,given $($conditional:ident),+ $(,)?) => {
+ ($value:ident in $start:expr => $end:expr, given $($conditional:ident),+ $(,)?) => {
  if !($start..=$end).contains(&$value) {
- return Err(ComponentRangeError);
+ return Err(ComponentRangeError {
+ name: stringify!($value),
+ minimum: i64::from($start),
+ maximum: i64::from($end),
+ value: i64::from($value),
+ given: vec![$((stringify!($conditional), i64::from($conditional))),+],
+ });
  };
  };
 }

src/time.rs

@@ -88,9 +88,9 @@ impl Time {
  #[cfg(feature = "panicking-api")]
  #[cfg_attr(doc, doc(cfg(feature = "panicking-api")))]
  pub fn from_hms(hour: u8, minute: u8, second: u8) -> Self {
- assert_value_in_range!(hour in 0 => exclusive 24);
- assert_value_in_range!(minute in 0 => exclusive 60);
- assert_value_in_range!(second in 0 => exclusive 60);
+ assert_value_in_range!(hour in 0 => 23);
+ assert_value_in_range!(minute in 0 => 59);
+ assert_value_in_range!(second in 0 => 59);
  Self {
  hour,
  minute,
@@ -116,9 +116,9 @@ impl Time {
  /// ```
  #[inline(always)]
  pub fn try_from_hms(hour: u8, minute: u8, second: u8) -> Result<Self, ComponentRangeError> {
- ensure_value_in_range!(hour in 0 => exclusive 24);
- ensure_value_in_range!(minute in 0 => exclusive 60);
- ensure_value_in_range!(second in 0 => exclusive 60);
+ ensure_value_in_range!(hour in 0 => 23);
+ ensure_value_in_range!(minute in 0 => 59);
+ ensure_value_in_range!(second in 0 => 59);
  Ok(Self {
  hour,
  minute,
@@ -164,10 +164,10 @@ impl Time {
  #[cfg(feature = "panicking-api")]
  #[cfg_attr(doc, doc(cfg(feature = "panicking-api")))]
  pub fn from_hms_milli(hour: u8, minute: u8, second: u8, millisecond: u16) -> Self {
- assert_value_in_range!(hour in 0 => exclusive 24);
- assert_value_in_range!(minute in 0 => exclusive 60);
- assert_value_in_range!(second in 0 => exclusive 60);
- assert_value_in_range!(millisecond in 0 => exclusive 1_000);
+ assert_value_in_range!(hour in 0 => 23);
+ assert_value_in_range!(minute in 0 => 59);
+ assert_value_in_range!(second in 0 => 59);
+ assert_value_in_range!(millisecond in 0 => 999);
  Self {
  hour,
  minute,
@@ -199,10 +199,10 @@ impl Time {
  second: u8,
  millisecond: u16,
  ) -> Result<Self, ComponentRangeError> {
- ensure_value_in_range!(hour in 0 => exclusive 24);
- ensure_value_in_range!(minute in 0 => exclusive 60);
- ensure_value_in_range!(second in 0 => exclusive 60);
- ensure_value_in_range!(millisecond in 0 => exclusive 1_000);
+ ensure_value_in_range!(hour in 0 => 23);
+ ensure_value_in_range!(minute in 0 => 59);
+ ensure_value_in_range!(second in 0 => 59);
+ ensure_value_in_range!(millisecond in 0 => 999);
  Ok(Self {
  hour,
  minute,
@@ -248,10 +248,10 @@ impl Time {
  #[cfg(feature = "panicking-api")]
  #[cfg_attr(doc, doc(cfg(feature = "panicking-api")))]
  pub fn from_hms_micro(hour: u8, minute: u8, second: u8, microsecond: u32) -> Self {
- assert_value_in_range!(hour in 0 => exclusive 24);
- assert_value_in_range!(minute in 0 => exclusive 60);
- assert_value_in_range!(second in 0 => exclusive 60);
- assert_value_in_range!(microsecond in 0 => exclusive 1_000_000);
+ assert_value_in_range!(hour in 0 => 23);
+ assert_value_in_range!(minute in 0 => 59);
+ assert_value_in_range!(second in 0 => 59);
+ assert_value_in_range!(microsecond in 0 => 999_999);
  Self {
  hour,
  minute,
@@ -283,10 +283,10 @@ impl Time {
  second: u8,
  microsecond: u32,
  ) -> Result<Self, ComponentRangeError> {
- ensure_value_in_range!(hour in 0 => exclusive 24);
- ensure_value_in_range!(minute in 0 => exclusive 60);
- ensure_value_in_range!(second in 0 => exclusive 60);
- ensure_value_in_range!(microsecond in 0 => exclusive 1_000_000);
+ ensure_value_in_range!(hour in 0 => 23);
+ ensure_value_in_range!(minute in 0 => 59);
+ ensure_value_in_range!(second in 0 => 59);
+ ensure_value_in_range!(microsecond in 0 => 999_999);
  Ok(Self {
  hour,
  minute,
@@ -331,10 +331,10 @@ impl Time {
  #[cfg(feature = "panicking-api")]
  #[cfg_attr(doc, doc(cfg(feature = "panicking-api")))]
  pub fn from_hms_nano(hour: u8, minute: u8, second: u8, nanosecond: u32) -> Self {
- assert_value_in_range!(hour in 0 => exclusive 24);
- assert_value_in_range!(minute in 0 => exclusive 60);
- assert_value_in_range!(second in 0 => exclusive 60);
- assert_value_in_range!(nanosecond in 0 => exclusive 1_000_000_000);
+ assert_value_in_range!(hour in 0 => 23);
+ assert_value_in_range!(minute in 0 => 59);
+ assert_value_in_range!(second in 0 => 59);
+ assert_value_in_range!(nanosecond in 0 => 999_999_999);
  Self {
  hour,
  minute,
@@ -366,10 +366,10 @@ impl Time {
  second: u8,
  nanosecond: u32,
  ) -> Result<Self, ComponentRangeError> {
- ensure_value_in_range!(hour in 0 => exclusive 24);
- ensure_value_in_range!(minute in 0 => exclusive 60);
- ensure_value_in_range!(second in 0 => exclusive 60);
- ensure_value_in_range!(nanosecond in 0 => exclusive 1_000_000_000);
+ ensure_value_in_range!(hour in 0 => 23);
+ ensure_value_in_range!(minute in 0 => 59);
+ ensure_value_in_range!(second in 0 => 59);
+ ensure_value_in_range!(nanosecond in 0 => 999_999_999);
  Ok(Self {
  hour,
  minute,