Reduce (and lint-disallow) panics in main code (#506)

Aside from datagen/sys code, this stops `temporal_rs` from panicking
when unexpected things occur. In general a JS engine should not panic;
it should throw an error or have GIGO behavior.

ICU4X follows a similar policy.

It would be nice to make sure none of the arithmetic can panic as well;
though at least in release builds it'll wrap or do other GIGO, which
seems fine.

Author: Manishearth

provider/src/lib.rs

@@ -5,6 +5,10 @@
 //!
 
 #![no_std]
+#![cfg_attr(
+    not(test),
+    warn(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing)
+)]
 
 extern crate alloc;
 

provider/src/posix.rs

@@ -16,6 +16,7 @@ pub struct PosixZone {
 }
 
 #[cfg(feature = "datagen")]
+#[allow(clippy::unwrap_used, reason = "Datagen only")]
 impl From<&PosixTimeZone> for PosixZone {
     fn from(value: &PosixTimeZone) -> Self {
         let abbr = TinyAsciiStr::<5>::try_from_str(&value.abbr.formatted).unwrap();
@@ -48,6 +49,7 @@ pub struct ZeroPosixTransition {
 }
 
 #[cfg(feature = "datagen")]
+#[allow(clippy::unwrap_used, reason = "Datagen only")]
 impl From<&PosixTransition> for ZeroPosixTransition {
     fn from(value: &PosixTransition) -> Self {
         let abbr = TinyAsciiStr::<5>::try_from_str(&value.abbr.formatted).unwrap();

provider/src/tzdb.rs

@@ -114,6 +114,7 @@ pub enum IanaDataError {
 }
 
 #[cfg(feature = "datagen")]
+#[allow(clippy::expect_used, clippy::unwrap_used, reason = "Datagen only")]
 impl IanaIdentifierNormalizer<'_> {
     pub fn build(tzdata_path: &Path) -> Result<Self, IanaDataError> {
         let provider = TzdbDataSource::try_from_zoneinfo_directory(tzdata_path)

provider/src/tzif.rs

@@ -109,6 +109,7 @@ pub enum ZoneInfoDataError {
 }
 
 #[cfg(feature = "datagen")]
+#[allow(clippy::expect_used, clippy::unwrap_used, reason = "Datagen only")]
 impl ZoneInfoProvider<'_> {
     pub fn build(tzdata: &Path) -> Result<Self, ZoneInfoDataError> {
         let tzdb_source = TzdbDataSource::try_from_rearguard_zoneinfo_dir(tzdata).unwrap();

src/builtins/compiled/zoneddatetime.rs

@@ -18,16 +18,17 @@ impl core::fmt::Display for ZonedDateTime {
     ///
     /// Enable with the `compiled_data` feature flag.
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_str(
-            &self
-                .to_ixdtf_string(
-                    DisplayOffset::Auto,
-                    DisplayTimeZone::Auto,
-                    DisplayCalendar::Auto,
-                    ToStringRoundingOptions::default(),
-                )
-                .expect("A valid ZonedDateTime string with default options."),
-        )
+        let string = self.to_ixdtf_string(
+            DisplayOffset::Auto,
+            DisplayTimeZone::Auto,
+            DisplayCalendar::Auto,
+            ToStringRoundingOptions::default(),
+        );
+        debug_assert!(
+            string.is_ok(),
+            "A valid ZonedDateTime string with default options."
+        );
+        f.write_str(&string.map_err(|_| Default::default())?)
     }
 }
 

src/builtins/core/datetime.rs

@@ -183,10 +183,15 @@ pub struct PlainDateTime {
 
 impl core::fmt::Display for PlainDateTime {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        let ixdtf_str = self
-            .to_ixdtf_string(ToStringRoundingOptions::default(), DisplayCalendar::Auto)
-            .expect("ixdtf default configuration should not fail.");
-        f.write_str(&ixdtf_str)
+        let string =
+            self.to_ixdtf_string(ToStringRoundingOptions::default(), DisplayCalendar::Auto);
+
+        debug_assert!(
+            string.is_ok(),
+            "Duration must return a valid string with default options."
+        );
+
+        f.write_str(&string.map_err(|_| Default::default())?)
     }
 }
 

src/builtins/core/duration.rs

@@ -299,11 +299,13 @@ pub struct Duration {
 
 impl core::fmt::Display for Duration {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_str(
-            &self
-                .as_temporal_string(ToStringRoundingOptions::default())
-                .expect("Duration must return a valid string with default options."),
-        )
+        let string = self.as_temporal_string(ToStringRoundingOptions::default());
+
+        debug_assert!(
+            string.is_ok(),
+            "Duration must return a valid string with default options."
+        );
+        f.write_str(&string.map_err(|_| Default::default())?)
     }
 }
 

src/builtins/core/duration/normalized.rs

@@ -14,7 +14,7 @@ use crate::{
     primitive::FiniteF64,
     provider::TimeZoneProvider,
     rounding::IncrementRounder,
-    Calendar, TemporalError, TemporalResult, TemporalUnwrap, NS_PER_DAY,
+    Calendar, TemporalError, TemporalResult, TemporalUnwrap, NS_PER_DAY, NS_PER_DAY_NONZERO,
 };
 
 use super::{DateDuration, Duration, Sign, TimeDuration};
@@ -157,7 +157,7 @@ impl NormalizedTimeDuration {
     ) -> TemporalResult<i64> {
         let adjusted_increment = increment
             .as_extended_increment()
-            .saturating_mul(NonZeroU128::new(NS_PER_DAY as u128).expect("cannot fail"));
+            .saturating_mul(NS_PER_DAY_NONZERO);
         let rounded =
             IncrementRounder::<i128>::from_signed_num(self.0, adjusted_increment)?.round(mode);
         Ok((rounded / NS_PER_DAY_128BIT) as i64)
@@ -831,11 +831,10 @@ impl NormalizedDurationRecord {
         // 5. Let done be false.
         // 6. Repeat, while unitIndex ≥ largestUnitIndex and done is false,
         //     a. Let unit be the value in the "Value" column of Table 21 in the row whose ordinal index is unitIndex.
-        for unit in UNIT_VALUE_TABLE[largest_unit_index..smallest_unit_index]
-            .iter()
-            .rev()
-            .copied()
-        {
+        let unit_values = UNIT_VALUE_TABLE
+            .get(largest_unit_index..smallest_unit_index)
+            .temporal_unwrap()?;
+        for unit in unit_values.iter().rev().copied() {
             // b. If unit is not week, or largestUnit is week, then
             if unit != Unit::Week || largest_unit == Unit::Week {
                 let end_duration = match unit {

src/builtins/core/zoneddatetime.rs

@@ -1461,11 +1461,9 @@ pub(crate) fn interpret_isodatetime_offset(
                 // c. If matchBehaviour is match-minutes, then
                 if match_minutes {
                     // i. Let roundedCandidateNanoseconds be RoundNumberToIncrement(candidateOffset, 60 × 10**9, half-expand).
-                    let rounded_candidate = IncrementRounder::from_signed_num(
-                        candidate_offset,
-                        NonZeroU128::new(60_000_000_000).expect("cannot be zero"), // TODO: Add back const { } after MSRV can be bumped
-                    )?
-                    .round(RoundingMode::HalfExpand);
+                    let rounded_candidate =
+                        IncrementRounder::from_signed_num(candidate_offset, NS_PER_MINUTE_NONZERO)?
+                            .round(RoundingMode::HalfExpand);
                     // ii. If roundedCandidateNanoseconds = offsetNanoseconds, then
                     if rounded_candidate == offset.into() {
                         // 1. Return candidate.

src/iso.rs

@@ -537,7 +537,9 @@ impl IsoDate {
 impl IsoDate {
     /// Creates `[[ISOYear]]`, `[[isoMonth]]`, `[[isoDay]]` fields from `ICU4X`'s `Date<Iso>` struct.
     pub(crate) fn to_icu4x(self) -> IcuDate<Iso> {
-        IcuDate::try_new_iso(self.year, self.month, self.day).expect("must not fail.")
+        let d = IcuDate::try_new_iso(self.year, self.month, self.day);
+        debug_assert!(d.is_ok(), "ICU4X ISODate conversion must not fail");
+        d.unwrap_or_else(|_| IcuDate::from_rata_die(icu_calendar::types::RataDie::new(0), Iso))
     }
 }