chore: checkpoint before Python removal

vendor/time/benchmarks/date.rs

@@ -0,0 +1,358 @@
+#![expect(
+    clippy::large_stack_frames,
+    reason = "iterating over large array; does not cause stack overflow"
+)]
+
+use std::hint::black_box as bb;
+use std::sync::LazyLock;
+
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::date;
+use time::{Date, Time};
+
+/// Generate a representative sample of all dates.
+///
+/// The ratio of month sizes, week sizes, year sign, leap years, etc. are all identical to the full
+/// range. This ensures that benchmarks accurately reflect random data.
+//
+// Note that this is a _very_ large array (over 1 MiB), so we silence the warning about large stack
+// frames at the top of this file.
+fn representative_dates() -> [Date; 292_194] {
+    static DATES: LazyLock<[Date; 292_194]> = LazyLock::new(|| {
+        let mut dates = [Date::MIN; _];
+        let mut current = date!(-0400-01-01);
+        let mut i = 0;
+        while current < date!(0400-01-01) {
+            dates[i] = current;
+            current = current.next_day().expect("date is in range");
+            i += 1;
+        }
+        crate::shuffle(dates)
+    });
+
+    *DATES
+}
+
+setup_benchmark! {
+    "Date",
+
+    fn noop(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(date);
+            }
+        });
+    }
+
+    fn noop_windows(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates().windows(2) {
+                let first = date[0];
+                let second = date[1];
+                let _ = bb((bb(first), bb(second)));
+            }
+        });
+    }
+
+    fn from_calendar_date(ben: &mut Bencher<'_>) {
+        let dates = representative_dates().map(Date::to_calendar_date);
+        ben.iter(|| {
+            for (year, month, day) in dates {
+                let _ = bb(Date::from_calendar_date(bb(year), bb(month), bb(day)));
+            }
+        });
+    }
+
+    fn from_ordinal_date(ben: &mut Bencher<'_>) {
+        let dates = representative_dates().map(Date::to_ordinal_date);
+        ben.iter(|| {
+            for (year, ordinal) in dates {
+                let _ = bb(Date::from_ordinal_date(bb(year), bb(ordinal)));
+            }
+        });
+
+    }
+
+    fn from_iso_week_date(ben: &mut Bencher<'_>) {
+        let dates = representative_dates().map(Date::to_iso_week_date);
+        ben.iter(|| {
+            for (year, week, weekday) in dates {
+                let _ = bb(Date::from_iso_week_date(bb(year), bb(week), bb(weekday)));
+            }
+        });
+    }
+
+    fn from_julian_day(ben: &mut Bencher<'_>) {
+        let dates = representative_dates().map(Date::to_julian_day);
+        ben.iter(|| {
+            for julian_day in dates {
+                let _ = bb(Date::from_julian_day(bb(julian_day)));
+            }
+        });
+    }
+
+    fn year(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).year());
+            }
+        });
+    }
+
+    fn month(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).month());
+            }
+        });
+    }
+
+    fn day(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).day());
+            }
+        });
+    }
+
+    fn ordinal(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).ordinal());
+            }
+        });
+    }
+
+    fn iso_week(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).iso_week());
+            }
+        });
+    }
+
+    fn sunday_based_week(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).sunday_based_week());
+            }
+        });
+    }
+
+    fn monday_based_week(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).monday_based_week());
+            }
+        });
+    }
+
+    fn to_calendar_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).to_calendar_date());
+            }
+        });
+    }
+
+    fn to_ordinal_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).to_ordinal_date());
+            }
+        });
+    }
+
+    fn to_iso_week_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).to_iso_week_date());
+            }
+        });
+    }
+
+    fn weekday(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).weekday());
+            }
+        });
+    }
+
+    fn next_day(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).next_day());
+            }
+        });
+    }
+
+    fn previous_day(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).previous_day());
+            }
+        });
+    }
+
+    fn to_julian_day(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).to_julian_day());
+            }
+        });
+    }
+
+    fn midnight(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).midnight());
+            }
+        });
+    }
+
+    fn with_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).with_time(bb(Time::MIDNIGHT)));
+            }
+        });
+    }
+
+    fn with_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).with_hms(bb(0), bb(0), bb(0)));
+            }
+        });
+    }
+
+    fn with_hms_milli(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).with_hms_milli(bb(0), bb(0), bb(0), bb(0)));
+            }
+        });
+    }
+
+    fn with_hms_micro(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).with_hms_micro(bb(0), bb(0), bb(0), bb(0)));
+            }
+        });
+    }
+
+    fn with_hms_nano(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date).with_hms_nano(bb(0), bb(0), bb(0), bb(0)));
+            }
+        });
+    }
+
+    fn add(ben: &mut Bencher<'_>) {
+        let dt = 5.days();
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date) + bb(dt));
+            }
+        });
+    }
+
+    fn add_std(ben: &mut Bencher<'_>) {
+        let dt = 5.std_days();
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date) - bb(dt));
+            }
+        });
+    }
+
+    fn add_assign(ben: &mut Bencher<'_>) {
+        let dt = 1.days();
+        ben.iter(|| {
+            for mut date in representative_dates() {
+                date += bb(dt);
+                let _ = bb(date);
+            }
+        });
+    }
+
+    fn add_assign_std(ben: &mut Bencher<'_>) {
+        let dt = 1.std_days();
+        ben.iter(|| {
+            for mut date in representative_dates() {
+                date += bb(dt);
+                let _ = bb(date);
+            }
+        });
+    }
+
+    fn sub(ben: &mut Bencher<'_>) {
+        let dt = 5.days();
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date) - bb(dt));
+            }
+        });
+    }
+
+    fn sub_std(ben: &mut Bencher<'_>) {
+        let dt = 5.std_days();
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date) - bb(dt));
+            }
+        });
+    }
+
+    fn sub_assign(ben: &mut Bencher<'_>) {
+        let dt = 1.days();
+        ben.iter(|| {
+            for mut date in representative_dates() {
+                date -= bb(dt);
+                let _ = bb(date);
+            }
+        });
+    }
+
+    fn sub_assign_std(ben: &mut Bencher<'_>) {
+        let dt = 1.std_days();
+        ben.iter(|| {
+            for mut date in representative_dates() {
+                date -= bb(dt);
+                let _ = bb(date);
+            }
+        });
+    }
+
+    fn sub_self(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates() {
+                let _ = bb(bb(date) - bb(date));
+            }
+        });
+    }
+
+    fn partial_ord(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates().windows(2) {
+                let first = date[0];
+                let second = date[1];
+                let _ = bb(bb(first).partial_cmp(&bb(second)));
+            }
+        });
+    }
+
+    fn ord(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for date in representative_dates().windows(2) {
+                let first = date[0];
+                let second = date[1];
+                let _ = bb(bb(first).cmp(&bb(second)));
+            }
+        });
+    }
+}

vendor/time/benchmarks/duration.rs

@@ -0,0 +1,714 @@
+use std::time::Duration as StdDuration;
+
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::Duration;
+
+setup_benchmark! {
+    "Duration",
+
+    fn is_zero(ben: &mut Bencher<'_>) {
+        let a = (-1).nanoseconds();
+        let b = 0.seconds();
+        let c = 1.nanoseconds();
+        ben.iter(|| a.is_zero());
+        ben.iter(|| b.is_zero());
+        ben.iter(|| c.is_zero());
+    }
+
+    fn is_negative(ben: &mut Bencher<'_>) {
+        let a = (-1).seconds();
+        let b = 0.seconds();
+        let c = 1.seconds();
+        ben.iter(|| a.is_negative());
+        ben.iter(|| b.is_negative());
+        ben.iter(|| c.is_negative());
+    }
+
+    fn is_positive(ben: &mut Bencher<'_>) {
+        let a = (-1).seconds();
+        let b = 0.seconds();
+        let c = 1.seconds();
+        ben.iter(|| a.is_positive());
+        ben.iter(|| b.is_positive());
+        ben.iter(|| c.is_positive());
+    }
+
+    fn abs(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 0.seconds();
+        let c = (-1).seconds();
+        ben.iter(|| a.abs());
+        ben.iter(|| b.abs());
+        ben.iter(|| c.abs());
+    }
+
+    fn unsigned_abs(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 0.seconds();
+        let c = (-1).seconds();
+        ben.iter(|| a.unsigned_abs());
+        ben.iter(|| b.unsigned_abs());
+        ben.iter(|| c.unsigned_abs());
+    }
+
+    fn new(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::new(1, 0));
+        ben.iter(|| Duration::new(-1, 0));
+        ben.iter(|| Duration::new(1, 2_000_000_000));
+
+        ben.iter(|| Duration::new(0, 0));
+        ben.iter(|| Duration::new(0, 1_000_000_000));
+        ben.iter(|| Duration::new(-1, 1_000_000_000));
+        ben.iter(|| Duration::new(-2, 1_000_000_000));
+
+        ben.iter(|| Duration::new(1, -1));
+        ben.iter(|| Duration::new(-1, 1));
+        ben.iter(|| Duration::new(1, 1));
+        ben.iter(|| Duration::new(-1, -1));
+        ben.iter(|| Duration::new(0, 1));
+        ben.iter(|| Duration::new(0, -1));
+
+        ben.iter(|| Duration::new(-1, 1_400_000_000));
+        ben.iter(|| Duration::new(-2, 1_400_000_000));
+        ben.iter(|| Duration::new(-3, 1_400_000_000));
+        ben.iter(|| Duration::new(1, -1_400_000_000));
+        ben.iter(|| Duration::new(2, -1_400_000_000));
+        ben.iter(|| Duration::new(3, -1_400_000_000));
+    }
+
+    fn weeks(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::weeks(1));
+        ben.iter(|| Duration::weeks(2));
+        ben.iter(|| Duration::weeks(-1));
+        ben.iter(|| Duration::weeks(-2));
+    }
+
+    fn days(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::days(1));
+        ben.iter(|| Duration::days(2));
+        ben.iter(|| Duration::days(-1));
+        ben.iter(|| Duration::days(-2));
+    }
+
+    fn hours(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::hours(1));
+        ben.iter(|| Duration::hours(2));
+        ben.iter(|| Duration::hours(-1));
+        ben.iter(|| Duration::hours(-2));
+    }
+
+    fn minutes(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::minutes(1));
+        ben.iter(|| Duration::minutes(2));
+        ben.iter(|| Duration::minutes(-1));
+        ben.iter(|| Duration::minutes(-2));
+    }
+
+    fn seconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::seconds(1));
+        ben.iter(|| Duration::seconds(2));
+        ben.iter(|| Duration::seconds(-1));
+        ben.iter(|| Duration::seconds(-2));
+    }
+
+    fn seconds_f64(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::seconds_f64(0.5));
+        ben.iter(|| Duration::seconds_f64(-0.5));
+    }
+
+    fn seconds_f32(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::seconds_f32(0.5));
+        ben.iter(|| Duration::seconds_f32(-0.5));
+    }
+
+    fn saturating_seconds_f64(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::saturating_seconds_f64(0.5));
+        ben.iter(|| Duration::saturating_seconds_f64(-0.5));
+    }
+
+    fn saturating_seconds_f32(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::saturating_seconds_f32(0.5));
+        ben.iter(|| Duration::saturating_seconds_f32(-0.5));
+    }
+
+    fn checked_seconds_f64(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::checked_seconds_f64(0.5));
+        ben.iter(|| Duration::checked_seconds_f64(-0.5));
+    }
+
+    fn checked_seconds_f32(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::checked_seconds_f32(0.5));
+        ben.iter(|| Duration::checked_seconds_f32(-0.5));
+    }
+
+    fn milliseconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::milliseconds(1));
+        ben.iter(|| Duration::milliseconds(-1));
+    }
+
+    fn microseconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::microseconds(1));
+        ben.iter(|| Duration::microseconds(-1));
+    }
+
+    fn nanoseconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| Duration::nanoseconds(1));
+        ben.iter(|| Duration::nanoseconds(-1));
+    }
+
+    fn whole_weeks(ben: &mut Bencher<'_>) {
+        let a = Duration::weeks(1);
+        let b = Duration::weeks(-1);
+        let c = Duration::days(6);
+        let d = Duration::days(-6);
+        ben.iter(|| a.whole_weeks());
+        ben.iter(|| b.whole_weeks());
+        ben.iter(|| c.whole_weeks());
+        ben.iter(|| d.whole_weeks());
+    }
+
+    fn whole_days(ben: &mut Bencher<'_>) {
+        let a = Duration::days(1);
+        let b = Duration::days(-1);
+        let c = Duration::hours(23);
+        let d = Duration::hours(-23);
+        ben.iter(|| a.whole_days());
+        ben.iter(|| b.whole_days());
+        ben.iter(|| c.whole_days());
+        ben.iter(|| d.whole_days());
+    }
+
+    fn whole_hours(ben: &mut Bencher<'_>) {
+        let a = Duration::hours(1);
+        let b = Duration::hours(-1);
+        let c = Duration::minutes(59);
+        let d = Duration::minutes(-59);
+        ben.iter(|| a.whole_hours());
+        ben.iter(|| b.whole_hours());
+        ben.iter(|| c.whole_hours());
+        ben.iter(|| d.whole_hours());
+    }
+
+    fn whole_minutes(ben: &mut Bencher<'_>) {
+        let a = 1.minutes();
+        let b = (-1).minutes();
+        let c = 59.seconds();
+        let d = (-59).seconds();
+        ben.iter(|| a.whole_minutes());
+        ben.iter(|| b.whole_minutes());
+        ben.iter(|| c.whole_minutes());
+        ben.iter(|| d.whole_minutes());
+    }
+
+    fn whole_seconds(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 1.minutes();
+        let d = (-1).minutes();
+        ben.iter(|| a.whole_seconds());
+        ben.iter(|| b.whole_seconds());
+        ben.iter(|| c.whole_seconds());
+        ben.iter(|| d.whole_seconds());
+    }
+
+    fn as_seconds_f64(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 1.minutes();
+        let d = (-1).minutes();
+        let e = 1.5.seconds();
+        let f = (-1.5).seconds();
+        ben.iter(|| a.as_seconds_f64());
+        ben.iter(|| b.as_seconds_f64());
+        ben.iter(|| c.as_seconds_f64());
+        ben.iter(|| d.as_seconds_f64());
+        ben.iter(|| e.as_seconds_f64());
+        ben.iter(|| f.as_seconds_f64());
+    }
+
+    fn as_seconds_f32(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 1.minutes();
+        let d = (-1).minutes();
+        let e = 1.5.seconds();
+        let f = (-1.5).seconds();
+        ben.iter(|| a.as_seconds_f32());
+        ben.iter(|| b.as_seconds_f32());
+        ben.iter(|| c.as_seconds_f32());
+        ben.iter(|| d.as_seconds_f32());
+        ben.iter(|| e.as_seconds_f32());
+        ben.iter(|| f.as_seconds_f32());
+    }
+
+    fn whole_milliseconds(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 1.milliseconds();
+        let d = (-1).milliseconds();
+        ben.iter(|| a.whole_milliseconds());
+        ben.iter(|| b.whole_milliseconds());
+        ben.iter(|| c.whole_milliseconds());
+        ben.iter(|| d.whole_milliseconds());
+    }
+
+    fn subsec_milliseconds(ben: &mut Bencher<'_>) {
+        let a = 1.4.seconds();
+        let b = (-1.4).seconds();
+        ben.iter(|| a.subsec_milliseconds());
+        ben.iter(|| b.subsec_milliseconds());
+    }
+
+    fn whole_microseconds(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = (-1).milliseconds();
+        let c = 1.microseconds();
+        let d = (-1).microseconds();
+        ben.iter(|| a.whole_microseconds());
+        ben.iter(|| b.whole_microseconds());
+        ben.iter(|| c.whole_microseconds());
+        ben.iter(|| d.whole_microseconds());
+    }
+
+    fn subsec_microseconds(ben: &mut Bencher<'_>) {
+        let a = 1.0004.seconds();
+        let b = (-1.0004).seconds();
+        ben.iter(|| a.subsec_microseconds());
+        ben.iter(|| b.subsec_microseconds());
+    }
+
+    fn whole_nanoseconds(ben: &mut Bencher<'_>) {
+        let a = 1.microseconds();
+        let b = (-1).microseconds();
+        let c = 1.nanoseconds();
+        let d = (-1).nanoseconds();
+        ben.iter(|| a.whole_nanoseconds());
+        ben.iter(|| b.whole_nanoseconds());
+        ben.iter(|| c.whole_nanoseconds());
+        ben.iter(|| d.whole_nanoseconds());
+    }
+
+    fn subsec_nanoseconds(ben: &mut Bencher<'_>) {
+        let a = 1.000_000_4.seconds();
+        let b = (-1.000_000_4).seconds();
+        ben.iter(|| a.subsec_nanoseconds());
+        ben.iter(|| b.subsec_nanoseconds());
+    }
+
+    fn checked_add(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MAX;
+        let c = (-5).seconds();
+
+        let a2 = 5.seconds();
+        let b2 = 1.nanoseconds();
+        let c2 = 5.seconds();
+
+        ben.iter(|| a.checked_add(a2));
+        ben.iter(|| b.checked_add(b2));
+        ben.iter(|| c.checked_add(c2));
+    }
+
+    fn checked_sub(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MIN;
+        let c = 5.seconds();
+
+        let a2 = 5.seconds();
+        let b2 = 1.nanoseconds();
+        let c2 = 10.seconds();
+
+        ben.iter(|| a.checked_sub(a2));
+        ben.iter(|| b.checked_sub(b2));
+        ben.iter(|| c.checked_sub(c2));
+    }
+
+    fn checked_mul(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MAX;
+        ben.iter(|| a.checked_mul(2));
+        ben.iter(|| b.checked_mul(2));
+    }
+
+    fn checked_div(ben: &mut Bencher<'_>) {
+        let a = 10.seconds();
+        ben.iter(|| a.checked_div(2));
+        ben.iter(|| a.checked_div(0));
+    }
+
+    fn saturating_add(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MAX;
+        let c = Duration::MIN;
+        let d = (-5).seconds();
+
+        let a2 = 5.seconds();
+        let b2 = 1.nanoseconds();
+        let c2 = (-1).nanoseconds();
+        let d2 = 5.seconds();
+
+        ben.iter(|| a.saturating_add(a2));
+        ben.iter(|| b.saturating_add(b2));
+        ben.iter(|| c.saturating_add(c2));
+        ben.iter(|| d.saturating_add(d2));
+    }
+
+    fn saturating_sub(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = Duration::MIN;
+        let c = Duration::MAX;
+        let d = 5.seconds();
+
+        let a2 = 5.seconds();
+        let b2 = 1.nanoseconds();
+        let c2 = (-1).nanoseconds();
+        let d2 = 10.seconds();
+
+        ben.iter(|| a.saturating_sub(a2));
+        ben.iter(|| b.saturating_sub(b2));
+        ben.iter(|| c.saturating_sub(c2));
+        ben.iter(|| d.saturating_sub(d2));
+    }
+
+    fn saturating_mul(ben: &mut Bencher<'_>) {
+        let a = 5.seconds();
+        let b = 5.seconds();
+        let c = 5.seconds();
+        let d = Duration::MAX;
+        let e = Duration::MIN;
+        let f = Duration::MAX;
+        let g = Duration::MIN;
+
+        ben.iter(|| a.saturating_mul(2));
+        ben.iter(|| b.saturating_mul(-2));
+        ben.iter(|| c.saturating_mul(0));
+        ben.iter(|| d.saturating_mul(2));
+        ben.iter(|| e.saturating_mul(2));
+        ben.iter(|| f.saturating_mul(-2));
+        ben.iter(|| g.saturating_mul(-2));
+    }
+
+    fn try_from_std_duration(ben: &mut Bencher<'_>) {
+        let a = 0.std_seconds();
+        let b = 1.std_seconds();
+        ben.iter(|| Duration::try_from(a));
+        ben.iter(|| Duration::try_from(b));
+    }
+
+    fn try_to_std_duration(ben: &mut Bencher<'_>) {
+        let a = 0.seconds();
+        let b = 1.seconds();
+        let c = (-1).seconds();
+        ben.iter(|| StdDuration::try_from(a));
+        ben.iter(|| StdDuration::try_from(b));
+        ben.iter(|| StdDuration::try_from(c));
+    }
+
+    fn add(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 2.seconds();
+        let c = 500.milliseconds();
+        let d = (-1).seconds();
+        ben.iter(|| a + b + c + d);
+    }
+
+    fn add_std(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 2.std_seconds();
+        ben.iter(|| a + b);
+    }
+
+    fn std_add(ben: &mut Bencher<'_>) {
+        let a = 1.std_seconds();
+        let b = 2.seconds();
+        ben.iter(|| a + b);
+    }
+
+    fn add_assign(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 500.milliseconds();
+        let c = (-1).seconds();
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration += a,
+                |duration| *duration += b,
+                |duration| *duration += c,
+            ]
+        );
+    }
+
+    fn add_assign_std(ben: &mut Bencher<'_>) {
+        let a = 1.std_seconds();
+        let b = 500.std_milliseconds();
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration += a,
+                |duration| *duration += b,
+            ]
+        );
+    }
+
+    fn neg(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = (-1).seconds();
+        let c = 0.seconds();
+        ben.iter(|| -a);
+        ben.iter(|| -b);
+        ben.iter(|| -c);
+    }
+
+    fn sub(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 1.seconds();
+        let c = 1_500.milliseconds();
+        let d = 500.milliseconds();
+        let e = 1.seconds();
+        let f = (-1).seconds();
+        ben.iter(|| a - b);
+        ben.iter(|| b - c);
+        ben.iter(|| c - d);
+        ben.iter(|| d - e);
+        ben.iter(|| e - f);
+        ben.iter(|| f - a);
+    }
+
+    fn sub_std(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 2.std_seconds();
+        ben.iter(|| a - b);
+    }
+
+    fn std_sub(ben: &mut Bencher<'_>) {
+        let a = 1.std_seconds();
+        let b = 2.seconds();
+        ben.iter(|| a - b);
+    }
+
+    fn sub_assign(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 500.milliseconds();
+        let c = (-1).seconds();
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration -= a,
+                |duration| *duration -= b,
+                |duration| *duration -= c,
+            ]
+        );
+    }
+
+    fn mul_int(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| d * 2);
+        ben.iter(|| d * -2);
+    }
+
+    fn mul_int_assign(ben: &mut Bencher<'_>) {
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration *= 2,
+                |duration| *duration *= -2,
+            ]
+        );
+    }
+
+    fn int_mul(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| 2 * d);
+        ben.iter(|| -2 * d);
+    }
+
+    fn div_int(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| d / 2);
+        ben.iter(|| d / -2);
+    }
+
+    fn div_int_assign(ben: &mut Bencher<'_>) {
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration /= 2,
+                |duration| *duration /= -2,
+            ]
+        );
+    }
+
+    fn div(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 0.5.seconds();
+        ben.iter(|| a / b);
+    }
+
+    fn mul_float(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| d * 1.5_f32);
+        ben.iter(|| d * 2.5_f32);
+        ben.iter(|| d * -1.5_f32);
+        ben.iter(|| d * 0_f32);
+        ben.iter(|| d * 1.5_f64);
+        ben.iter(|| d * 2.5_f64);
+        ben.iter(|| d * -1.5_f64);
+        ben.iter(|| d * 0_f64);
+    }
+
+    fn float_mul(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| 1.5_f32 * d);
+        ben.iter(|| 2.5_f32 * d);
+        ben.iter(|| -1.5_f32 * d);
+        ben.iter(|| 0_f32 * d);
+        ben.iter(|| 1.5_f64 * d);
+        ben.iter(|| 2.5_f64 * d);
+        ben.iter(|| -1.5_f64 * d);
+        ben.iter(|| 0_f64 * d);
+    }
+
+    fn mul_float_assign(ben: &mut Bencher<'_>) {
+        iter_batched_ref!(
+            ben,
+            || 1.seconds(),
+            [
+                |duration| *duration *= 1.5_f32,
+                |duration| *duration *= 2.5_f32,
+                |duration| *duration *= -1.5_f32,
+                |duration| *duration *= 3.15_f32,
+                |duration| *duration *= 1.5_f64,
+                |duration| *duration *= 2.5_f64,
+                |duration| *duration *= -1.5_f64,
+                |duration| *duration *= 0_f64,
+            ]
+        );
+    }
+
+    fn div_float(ben: &mut Bencher<'_>) {
+        let d = 1.seconds();
+        ben.iter(|| d / 1_f32);
+        ben.iter(|| d / 2_f32);
+        ben.iter(|| d / -1_f32);
+        ben.iter(|| d / 1_f64);
+        ben.iter(|| d / 2_f64);
+        ben.iter(|| d / -1_f64);
+    }
+
+    fn div_float_assign(ben: &mut Bencher<'_>) {
+        iter_batched_ref!(
+            ben,
+            || 10.seconds(),
+            [
+                |duration| *duration /= 1_f32,
+                |duration| *duration /= 2_f32,
+                |duration| *duration /= -1_f32,
+                |duration| *duration /= 1_f64,
+                |duration| *duration /= 2_f64,
+                |duration| *duration /= -1_f64,
+            ]
+        );
+    }
+
+    fn partial_eq(ben: &mut Bencher<'_>) {
+        let a = 1.minutes();
+        let b = (-1).minutes();
+        let c = 40.seconds();
+        ben.iter(|| a == b);
+        ben.iter(|| c == a);
+    }
+
+    fn partial_eq_std(ben: &mut Bencher<'_>) {
+        let a = (-1).seconds();
+        let b = 1.std_seconds();
+        let c = (-1).minutes();
+        let d = 1.std_minutes();
+        let e = 40.seconds();
+        ben.iter(|| a == b);
+        ben.iter(|| c == d);
+        ben.iter(|| e == d);
+    }
+
+    fn std_partial_eq(ben: &mut Bencher<'_>) {
+        let a = 1.std_seconds();
+        let b = (-1).seconds();
+        let c = 1.std_minutes();
+        let d = (-1).minutes();
+        let e = 40.std_seconds();
+        let f = 1.minutes();
+        ben.iter(|| a == b);
+        ben.iter(|| c == d);
+        ben.iter(|| e == f);
+    }
+
+    fn partial_ord(ben: &mut Bencher<'_>) {
+        let a = 0.seconds();
+        let b = 1.seconds();
+        let c = (-1).seconds();
+        let d = 1.minutes();
+        let e = (-1).minutes();
+        ben.iter(|| a.partial_cmp(&a));
+        ben.iter(|| b.partial_cmp(&a));
+        ben.iter(|| b.partial_cmp(&c));
+        ben.iter(|| c.partial_cmp(&b));
+        ben.iter(|| a.partial_cmp(&c));
+        ben.iter(|| a.partial_cmp(&b));
+        ben.iter(|| c.partial_cmp(&a));
+        ben.iter(|| d.partial_cmp(&b));
+        ben.iter(|| e.partial_cmp(&c));
+    }
+
+    fn partial_ord_std(ben: &mut Bencher<'_>) {
+        let a = 0.seconds();
+        let b = 0.std_seconds();
+        let c = 1.seconds();
+        let d = (-1).seconds();
+        let e = 1.std_seconds();
+        let f = 1.minutes();
+        let g = u64::MAX.std_seconds();
+        ben.iter(|| a.partial_cmp(&b));
+        ben.iter(|| c.partial_cmp(&b));
+        ben.iter(|| d.partial_cmp(&e));
+        ben.iter(|| a.partial_cmp(&e));
+        ben.iter(|| d.partial_cmp(&b));
+        ben.iter(|| f.partial_cmp(&e));
+        ben.iter(|| a.partial_cmp(&g));
+    }
+
+    fn std_partial_ord(ben: &mut Bencher<'_>) {
+        let a = 0.std_seconds();
+        let b = 0.seconds();
+        let c = 1.std_seconds();
+        let d = (-1).seconds();
+        let e = 1.seconds();
+        let f = 1.std_minutes();
+        ben.iter(|| a.partial_cmp(&b));
+        ben.iter(|| c.partial_cmp(&b));
+        ben.iter(|| c.partial_cmp(&d));
+        ben.iter(|| a.partial_cmp(&d));
+        ben.iter(|| a.partial_cmp(&e));
+        ben.iter(|| f.partial_cmp(&e));
+    }
+
+    fn ord(ben: &mut Bencher<'_>) {
+        let a = 1.seconds();
+        let b = 0.seconds();
+        let c = (-1).seconds();
+        let d = 1.minutes();
+        let e = (-1).minutes();
+        ben.iter(|| a > b);
+        ben.iter(|| a > c);
+        ben.iter(|| c < a);
+        ben.iter(|| b > c);
+        ben.iter(|| b < a);
+        ben.iter(|| c < b);
+        ben.iter(|| d > a);
+        ben.iter(|| e < c);
+    }
+}

vendor/time/benchmarks/formatting.rs

@@ -0,0 +1,190 @@
+use std::io;
+
+use criterion::Bencher;
+use time::format_description;
+use time::format_description::well_known::{Rfc2822, Rfc3339};
+use time::macros::{date, datetime, format_description as fd, offset, time};
+
+setup_benchmark! {
+    "Formatting",
+
+    fn format_rfc3339(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($value:expr) => {
+                $value.format_into(&mut io::sink(), &Rfc3339)
+            }
+        }
+
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.1 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.12 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_4 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_45 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_7 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_78 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_789 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_789 -01:02)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05.123_456_789 +01:02)));
+    }
+
+    fn format_rfc2822(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($value:expr) => {
+                $value.format_into(&mut io::sink(), &Rfc2822)
+            }
+        }
+
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05 UTC)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05 +06:07)));
+        ben.iter(|| item!(datetime!(2021-01-02 03:04:05 -06:07)));
+    }
+
+
+    fn format_time(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($format:expr) => {
+                time!(13:02:03.456_789_012).format_into(
+                    &mut io::sink(),
+                    &$format,
+                )
+            }
+        }
+
+        ben.iter(|| item!(fd!("[hour]")));
+        ben.iter(|| item!(fd!("[hour repr:12]")));
+        ben.iter(|| item!(fd!("[hour repr:12 padding:none]")));
+        ben.iter(|| item!(fd!("[hour repr:12 padding:space]")));
+        ben.iter(|| item!(fd!("[hour repr:24]")));
+        ben.iter(|| item!(fd!("[hour repr:24]")));
+        ben.iter(|| item!(fd!("[hour repr:24 padding:none]")));
+        ben.iter(|| item!(fd!("[hour repr:24 padding:space]")));
+        ben.iter(|| item!(fd!("[minute]")));
+        ben.iter(|| item!(fd!("[minute padding:none]")));
+        ben.iter(|| item!(fd!("[minute padding:space]")));
+        ben.iter(|| item!(fd!("[minute padding:zero]")));
+        ben.iter(|| item!(fd!("[period]")));
+        ben.iter(|| item!(fd!("[period case:upper]")));
+        ben.iter(|| item!(fd!("[period case:lower]")));
+        ben.iter(|| item!(fd!("[second]")));
+        ben.iter(|| item!(fd!("[second padding:none]")));
+        ben.iter(|| item!(fd!("[second padding:space]")));
+        ben.iter(|| item!(fd!("[second padding:zero]")));
+        ben.iter(|| item!(fd!("[subsecond]")));
+        ben.iter(|| item!(fd!("[subsecond digits:1]")));
+        ben.iter(|| item!(fd!("[subsecond digits:2]")));
+        ben.iter(|| item!(fd!("[subsecond digits:3]")));
+        ben.iter(|| item!(fd!("[subsecond digits:4]")));
+        ben.iter(|| item!(fd!("[subsecond digits:5]")));
+        ben.iter(|| item!(fd!("[subsecond digits:6]")));
+        ben.iter(|| item!(fd!("[subsecond digits:7]")));
+        ben.iter(|| item!(fd!("[subsecond digits:8]")));
+        ben.iter(|| item!(fd!("[subsecond digits:9]")));
+        ben.iter(|| item!(fd!("[subsecond digits:1+]")));
+    }
+
+    fn display_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| time!(0:00).to_string());
+        ben.iter(|| time!(23:59).to_string());
+        ben.iter(|| time!(23:59:59).to_string());
+        ben.iter(|| time!(0:00:01).to_string());
+        ben.iter(|| time!(0:00:00.001).to_string());
+        ben.iter(|| time!(0:00:00.000_001).to_string());
+        ben.iter(|| time!(0:00:00.000_000_001).to_string());
+    }
+
+    fn format_date(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($format:expr) => {
+                date!(2019-12-31).format_into(&mut io::sink(), &$format)
+            }
+        }
+
+        ben.iter(|| item!(fd!("[day]")));
+        ben.iter(|| item!(fd!("[month]")));
+        ben.iter(|| item!(fd!("[month repr:short]")));
+        ben.iter(|| item!(fd!("[month repr:long]")));
+        ben.iter(|| item!(fd!("[ordinal]")));
+        ben.iter(|| item!(fd!("[weekday]")));
+        ben.iter(|| item!(fd!("[weekday repr:short]")));
+        ben.iter(|| item!(fd!("[weekday repr:sunday]")));
+        ben.iter(|| item!(fd!("[weekday repr:sunday one_indexed:false]")));
+        ben.iter(|| item!(fd!("[weekday repr:monday]")));
+        ben.iter(|| item!(fd!("[weekday repr:monday one_indexed:false]")));
+        ben.iter(|| item!(fd!("[week_number]")));
+        ben.iter(|| item!(fd!("[week_number padding:none]")));
+        ben.iter(|| item!(fd!("[week_number padding:space]")));
+        ben.iter(|| item!(fd!("[week_number repr:sunday]")));
+        ben.iter(|| item!(fd!("[week_number repr:monday]")));
+        ben.iter(|| item!(fd!("[year]")));
+        ben.iter(|| item!(fd!("[year base:iso_week]")));
+        ben.iter(|| item!(fd!("[year sign:mandatory]")));
+        ben.iter(|| item!(fd!("[year base:iso_week sign:mandatory]")));
+        ben.iter(|| item!(fd!("[year repr:last_two]")));
+        ben.iter(|| item!(fd!("[year base:iso_week repr:last_two]")));
+    }
+
+    fn display_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| date!(2019-01-01).to_string());
+        ben.iter(|| date!(2019-12-31).to_string());
+        ben.iter(|| date!(-4713-11-24).to_string());
+        ben.iter(|| date!(-0001-01-01).to_string());
+    }
+
+    fn format_offset(ben: &mut Bencher<'_>) {
+        macro_rules! item {
+            ($value:expr, $format:expr) => {
+                $value.format_into(&mut io::sink(), &$format)
+            }
+        }
+
+        ben.iter(|| item!(offset!(+01:02:03), fd!("[offset_hour sign:automatic]")));
+        ben.iter(|| item!(offset!(+01:02:03), fd!("[offset_hour sign:mandatory]")));
+        ben.iter(|| item!(offset!(-01:02:03), fd!("[offset_hour sign:automatic]")));
+        ben.iter(|| item!(offset!(-01:02:03), fd!("[offset_hour sign:mandatory]")));
+        ben.iter(|| item!(offset!(+01:02:03), fd!("[offset_minute]")));
+        ben.iter(|| item!(offset!(+01:02:03), fd!("[offset_second]")));
+    }
+
+    fn display_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| offset!(UTC).to_string());
+        ben.iter(|| offset!(+0:00:01).to_string());
+        ben.iter(|| offset!(-0:00:01).to_string());
+        ben.iter(|| offset!(+1).to_string());
+        ben.iter(|| offset!(-1).to_string());
+        ben.iter(|| offset!(+23:59).to_string());
+        ben.iter(|| offset!(-23:59).to_string());
+        ben.iter(|| offset!(+23:59:59).to_string());
+        ben.iter(|| offset!(-23:59:59).to_string());
+    }
+
+    fn format_pdt(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            datetime!(1970-01-01 0:00).format_into(
+                &mut io::sink(),
+                fd!("[year]-[month]-[day] [hour]:[minute]:[second].[subsecond]"),
+            )
+        });
+    }
+
+    fn display_pdt(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(1970-01-01 0:00).to_string());
+        ben.iter(|| datetime!(1970-01-01 0:00:01).to_string());
+    }
+
+    fn format_odt(ben: &mut Bencher<'_>) {
+        let format_description = format_description::parse(
+            "[year]-[month]-[day] [hour]:[minute]:[second].[subsecond] [offset_hour \
+            sign:mandatory]:[offset_minute]:[offset_second]",
+        ).expect("invalid format description");
+
+        ben.iter(|| {
+            datetime!(1970-01-01 0:00 UTC).format_into(&mut io::sink(), &format_description)
+        });
+    }
+
+    fn display_odt(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(1970-01-01 0:00 UTC).to_string());
+    }
+}

vendor/time/benchmarks/instant.rs

@@ -0,0 +1,89 @@
+#![expect(deprecated)]
+
+use std::time::Instant as StdInstant;
+
+use criterion::Bencher;
+use time::ext::NumericalDuration;
+use time::{Duration, Instant};
+
+setup_benchmark! {
+    "Instant",
+
+    fn checked_add(ben: &mut Bencher<'_>) {
+        let instant = Instant::now();
+        let dt = 5.seconds();
+        ben.iter(|| instant.checked_add(dt));
+    }
+
+    fn checked_sub(ben: &mut Bencher<'_>) {
+        let instant = Instant::now();
+        let dt = 5.seconds();
+        ben.iter(|| instant.checked_sub(dt));
+    }
+
+    fn sub(ben: &mut Bencher<'_>) {
+        let start: Instant = Instant::now();
+        let end: Instant = start + 1.milliseconds();
+        ben.iter(|| end - start);
+    }
+
+    fn add_duration(ben: &mut Bencher<'_>) {
+        let start = Instant::now();
+        let dt: Duration = 1.seconds();
+        ben.iter(|| start + dt);
+    }
+
+    fn std_add_duration(ben: &mut Bencher<'_>) {
+        let start = StdInstant::now();
+        let dt: Duration = 1.milliseconds();
+        ben.iter(|| start + dt);
+    }
+
+    fn add_assign_duration(ben: &mut Bencher<'_>) {
+        let dt: Duration = 1.milliseconds();
+        iter_batched_ref!(
+            ben,
+            Instant::now,
+            [|start| *start += dt]
+        );
+    }
+
+    fn std_add_assign_duration(ben: &mut Bencher<'_>) {
+        let dt: Duration = 1.milliseconds();
+        iter_batched_ref!(
+            ben,
+            StdInstant::now,
+            [|start| *start += dt]
+        );
+    }
+
+    fn sub_duration(ben: &mut Bencher<'_>) {
+        let instant = Instant::now();
+        let dt: Duration = 100.milliseconds();
+        ben.iter(|| instant - dt);
+    }
+
+    fn std_sub_duration(ben: &mut Bencher<'_>) {
+        let instant = StdInstant::now();
+        let dt: Duration = 100.milliseconds();
+        ben.iter(|| instant - dt);
+    }
+
+    fn sub_assign_duration(ben: &mut Bencher<'_>) {
+        let dt: Duration = 100.milliseconds();
+        iter_batched_ref!(
+            ben,
+            Instant::now,
+            [|instant| *instant -= dt]
+        );
+    }
+
+    fn std_sub_assign_duration(ben: &mut Bencher<'_>) {
+        let dt: Duration = 100.milliseconds();
+        iter_batched_ref!(
+            ben,
+            StdInstant::now,
+            [|instant| *instant -= dt]
+        );
+    }
+}

vendor/time/benchmarks/main.rs

@@ -0,0 +1,118 @@
+//! Benchmarks for `time`.
+//!
+//! These benchmarks are not very precise, but they're good enough to catch major performance
+//! regressions. Run them if you think that may be the case. CI **does not** run benchmarks.
+
+#![allow(
+    clippy::std_instead_of_core,
+    clippy::std_instead_of_alloc,
+    clippy::alloc_instead_of_core,
+    reason = "irrelevant for benchmarks"
+)]
+#![allow(
+    clippy::missing_docs_in_private_items,
+    reason = "may be removed in the future"
+)]
+
+#[cfg(not(all(
+    feature = "default",
+    feature = "alloc",
+    feature = "formatting",
+    feature = "large-dates",
+    feature = "local-offset",
+    feature = "macros",
+    feature = "parsing",
+    feature = "quickcheck",
+    feature = "serde-human-readable",
+    feature = "serde-well-known",
+    feature = "std",
+    feature = "rand",
+    feature = "serde",
+    bench,
+)))]
+compile_error!(
+    "benchmarks must be run as `RUSTFLAGS=\"--cfg bench\" cargo criterion --all-features`"
+);
+
+macro_rules! setup_benchmark {
+    (
+        $group_prefix:literal,
+        $(
+            $(#[$fn_attr:meta])*
+            fn $fn_name:ident ($bencher:ident : $bencher_type:ty)
+            $code:block
+        )*
+    ) => {
+        $(
+            $(#[$fn_attr])*
+            fn $fn_name(
+                c: &mut ::criterion::Criterion
+            ) {
+                c.bench_function(
+                    concat!($group_prefix, ": ", stringify!($fn_name)),
+                    |$bencher: $bencher_type| $code
+                );
+            }
+        )*
+
+        ::criterion::criterion_group! {
+            name = benches;
+            config = ::criterion::Criterion::default()
+                // Set a stricter statistical significance threshold ("p-value")
+                // for deciding what's an actual performance change vs. noise.
+                // The more benchmarks, the lower this needs to be in order to
+                // not get lots of false positives.
+                .significance_level(0.0001)
+                // Ignore any performance change less than this (0.05 = 5%) as
+                // noise, regardless of statistical significance.
+                .noise_threshold(0.05)
+                // Reduce the time taken to run each benchmark
+                .warm_up_time(::std::time::Duration::from_millis(100))
+                .measurement_time(::std::time::Duration::from_millis(500));
+            targets = $($fn_name,)*
+        }
+    };
+}
+
+macro_rules! iter_batched_ref {
+    ($ben:ident, $initializer:expr,[$($routine:expr),+ $(,)?]) => {$(
+        $ben.iter_batched_ref(
+            $initializer,
+            $routine,
+            ::criterion::BatchSize::SmallInput,
+        );
+    )+};
+}
+
+macro_rules! mods {
+    ($(mod $mod:ident;)+) => {
+        $(mod $mod;)+
+        ::criterion::criterion_main!($($mod::benches),+);
+    }
+}
+
+mods![
+    mod date;
+    mod duration;
+    mod formatting;
+    mod instant;
+    mod month;
+    mod offset_date_time;
+    mod parsing;
+    mod primitive_date_time;
+    mod rand08;
+    mod rand09;
+    mod time;
+    mod utc_offset;
+    mod util;
+    mod weekday;
+];
+
+/// Shuffle a slice in a random but deterministic manner.
+fn shuffle<T, const N: usize>(mut slice: [T; N]) -> [T; N] {
+    use ::rand09::prelude::*;
+
+    let mut seed = SmallRng::seed_from_u64(0);
+    slice.shuffle(&mut seed);
+    slice
+}

vendor/time/benchmarks/month.rs

@@ -0,0 +1,66 @@
+use criterion::Bencher;
+use time::Month::*;
+
+setup_benchmark! {
+    "Month",
+
+    fn previous(ben: &mut Bencher<'_>) {
+        ben.iter(|| January.previous());
+        ben.iter(|| February.previous());
+        ben.iter(|| March.previous());
+        ben.iter(|| April.previous());
+        ben.iter(|| May.previous());
+        ben.iter(|| June.previous());
+        ben.iter(|| July.previous());
+        ben.iter(|| August.previous());
+        ben.iter(|| September.previous());
+        ben.iter(|| October.previous());
+        ben.iter(|| November.previous());
+        ben.iter(|| December.previous());
+    }
+
+    fn next(ben: &mut Bencher<'_>) {
+        ben.iter(|| January.next());
+        ben.iter(|| February.next());
+        ben.iter(|| March.next());
+        ben.iter(|| April.next());
+        ben.iter(|| May.next());
+        ben.iter(|| June.next());
+        ben.iter(|| July.next());
+        ben.iter(|| August.next());
+        ben.iter(|| September.next());
+        ben.iter(|| October.next());
+        ben.iter(|| November.next());
+        ben.iter(|| December.next());
+    }
+
+    fn length(ben: &mut Bencher<'_>) {
+        // Common year
+        ben.iter(|| January.length(2019));
+        ben.iter(|| February.length(2019));
+        ben.iter(|| March.length(2019));
+        ben.iter(|| April.length(2019));
+        ben.iter(|| May.length(2019));
+        ben.iter(|| June.length(2019));
+        ben.iter(|| July.length(2019));
+        ben.iter(|| August.length(2019));
+        ben.iter(|| September.length(2019));
+        ben.iter(|| October.length(2019));
+        ben.iter(|| November.length(2019));
+        ben.iter(|| December.length(2019));
+
+        // Leap year
+        ben.iter(|| January.length(2020));
+        ben.iter(|| February.length(2020));
+        ben.iter(|| March.length(2020));
+        ben.iter(|| April.length(2020));
+        ben.iter(|| May.length(2020));
+        ben.iter(|| June.length(2020));
+        ben.iter(|| July.length(2020));
+        ben.iter(|| August.length(2020));
+        ben.iter(|| September.length(2020));
+        ben.iter(|| October.length(2020));
+        ben.iter(|| November.length(2020));
+        ben.iter(|| December.length(2020));
+    }
+}

vendor/time/benchmarks/offset_date_time.rs

@@ -0,0 +1,424 @@
+use std::hint::black_box;
+use std::time::SystemTime;
+
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::{date, datetime, offset, time};
+use time::OffsetDateTime;
+
+setup_benchmark! {
+    "OffsetDateTime",
+
+    fn now_utc(ben: &mut Bencher<'_>) {
+        ben.iter(OffsetDateTime::now_utc);
+    }
+
+    fn now_local(ben: &mut Bencher<'_>) {
+        ben.iter(OffsetDateTime::now_local);
+    }
+
+    fn to_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2000-01-01 0:00 +11).to_offset(offset!(-5)));
+        ben.iter(|| datetime!(2000-01-01 0:00 +11).to_offset(offset!(-8)));
+    }
+
+    fn to_utc(ben: &mut Bencher<'_>) {
+        ben.iter(|| black_box(datetime!(2000-01-01 0:00 +11).to_utc()));
+    }
+
+    fn from_unix_timestamp(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::from_unix_timestamp(0));
+        ben.iter(|| OffsetDateTime::from_unix_timestamp(1_546_300_800));
+    }
+
+    fn from_unix_timestamp_nanos(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::from_unix_timestamp_nanos(0));
+        ben.iter(|| OffsetDateTime::from_unix_timestamp_nanos(1_546_300_800_000_000_000));
+    }
+
+    fn offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).offset());
+        ben.iter(|| datetime!(2019-01-01 0:00 +1).offset());
+        ben.iter(|| datetime!(2019-01-01 1:00 +1).offset());
+    }
+
+    fn unix_timestamp(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::UNIX_EPOCH.unix_timestamp());
+        ben.iter(|| datetime!(1970-01-01 1:00 +1).unix_timestamp());
+        ben.iter(|| datetime!(1970-01-01 0:00 -1).unix_timestamp());
+    }
+
+    fn unix_timestamp_nanos(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(1970-01-01 0:00 UTC).unix_timestamp_nanos());
+        ben.iter(|| datetime!(1970-01-01 1:00 +1).unix_timestamp_nanos());
+        ben.iter(|| datetime!(1970-01-01 0:00 -1).unix_timestamp_nanos());
+    }
+
+    fn date(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).date());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).date());
+    }
+
+    fn time(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).time());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).time());
+    }
+
+    fn year(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).year());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).year());
+    }
+
+    fn ordinal(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).ordinal());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).ordinal());
+    }
+
+    fn hour(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).hour());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).hour());
+    }
+
+    fn minute(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).minute());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).minute());
+    }
+
+    fn second(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC).second());
+        ben.iter(|| datetime!(2018-12-31 23:00 -1).second());
+    }
+
+    fn replace_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2020-01-01 5:00 UTC).replace_time(time!(12:00)));
+        ben.iter(|| datetime!(2020-01-01 12:00 -5).replace_time(time!(7:00)));
+        ben.iter(|| datetime!(2020-01-01 0:00 +1).replace_time(time!(12:00)));
+    }
+
+    fn replace_date(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2020-01-01 12:00 UTC).replace_date(date!(2020-01-30)));
+        ben.iter(|| datetime!(2020-01-01 0:00 +1).replace_date(date!(2020-01-30)));
+    }
+
+    fn replace_date_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2020-01-01 12:00 UTC).replace_date_time(datetime!(2020-01-30 16:00)));
+        ben.iter(|| datetime!(2020-01-01 12:00 +1).replace_date_time(datetime!(2020-01-30 0:00)));
+    }
+
+    fn replace_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC).replace_offset(offset!(-5)));
+    }
+
+    fn partial_eq(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(1999-12-31 23:00 -1) == datetime!(2000-01-01 0:00 UTC));
+    }
+
+    fn partial_ord(ben: &mut Bencher<'_>) {
+        ben.iter(||
+            datetime!(2019-01-01 0:00 UTC).partial_cmp(&datetime!(1999-12-31 23:00 -1))
+        );
+    }
+
+    fn ord(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) == datetime!(2018-12-31 23:00 -1));
+        ben.iter(|| datetime!(2019-01-01 0:00:00.000_000_001 UTC) > datetime!(2019-01-01 0:00 UTC));
+    }
+
+    fn hash(ben: &mut Bencher<'_>) {
+        use std::collections::hash_map::DefaultHasher;
+        use std::hash::Hash;
+
+        iter_batched_ref!(
+            ben,
+            DefaultHasher::new,
+            [
+                |hasher| datetime!(2019-01-01 0:00 UTC).hash(hasher),
+                |hasher| datetime!(2018-12-31 23:00 -1).hash(hasher),
+            ]
+        );
+    }
+
+    fn add_duration(ben: &mut Bencher<'_>) {
+        let a = 5.days();
+        let b = 1.days();
+        let c = 2.seconds();
+        let d = (-2).seconds();
+        let e = 1.hours();
+
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) + a);
+        ben.iter(|| datetime!(2019-12-31 0:00 UTC) + b);
+        ben.iter(|| datetime!(2019-12-31 23:59:59 UTC) + c);
+        ben.iter(|| datetime!(2020-01-01 0:00:01 UTC) + d);
+        ben.iter(|| datetime!(1999-12-31 23:00 UTC) + e);
+    }
+
+    fn add_std_duration(ben: &mut Bencher<'_>) {
+        let a = 5.std_days();
+        let b = 1.std_days();
+        let c = 2.std_seconds();
+
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) + a);
+        ben.iter(|| datetime!(2019-12-31 0:00 UTC) + b);
+        ben.iter(|| datetime!(2019-12-31 23:59:59 UTC) + c);
+    }
+
+    fn add_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00 UTC),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn add_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_days();
+        let b = 1.std_seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00 UTC),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn sub_duration(ben: &mut Bencher<'_>) {
+        let a = 5.days();
+        let b = 1.days();
+        let c = 2.seconds();
+
+        ben.iter(|| datetime!(2019-01-06 0:00 UTC) - a);
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00:01 UTC) - c);
+    }
+
+    fn sub_std_duration(ben: &mut Bencher<'_>) {
+        let a = 5.std_days();
+        let b = 1.std_days();
+        let c = 2.std_seconds();
+
+        ben.iter(|| datetime!(2019-01-06 0:00 UTC) - a);
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00:01 UTC) - c);
+    }
+
+    fn sub_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00 UTC),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn sub_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_days();
+        let b = 1.std_seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00 UTC),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn std_add_duration(ben: &mut Bencher<'_>) {
+        let a1 = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let a2 = 0.seconds();
+        let b1 = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let b2 = 5.days();
+        let c1 = SystemTime::from(datetime!(2019-12-31 0:00 UTC));
+        let c2 = 1.days();
+        let d1 = SystemTime::from(datetime!(2019-12-31 23:59:59 UTC));
+        let d2 = 2.seconds();
+        let e1 = SystemTime::from(datetime!(2020-01-01 0:00:01 UTC));
+        let e2 = (-2).seconds();
+        ben.iter(|| a1 + a2);
+        ben.iter(|| b1 + b2);
+        ben.iter(|| c1 + c2);
+        ben.iter(|| d1 + d2);
+        ben.iter(|| e1 + e2);
+    }
+
+    fn std_add_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || SystemTime::from(datetime!(2019-01-01 0:00 UTC)),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn std_sub_duration(ben: &mut Bencher<'_>) {
+        let a1 = SystemTime::from(datetime!(2019-01-06 0:00 UTC));
+        let a2 = 5.days();
+        let b1 = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+        let b2 = 1.days();
+        let c1 = SystemTime::from(datetime!(2020-01-01 0:00:01 UTC));
+        let c2 = 2.seconds();
+        let d1 = SystemTime::from(datetime!(2019-12-31 23:59:59 UTC));
+        let d2 = (-2).seconds();
+        ben.iter(|| a1 - a2);
+        ben.iter(|| b1 - b2);
+        ben.iter(|| c1 - c2);
+        ben.iter(|| d1 - d2);
+    }
+
+    fn std_sub_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || SystemTime::from(datetime!(2019-01-01 0:00 UTC)),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn sub_self(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-02 0:00 UTC) - datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) - datetime!(2019-01-02 0:00 UTC));
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) - datetime!(2019-12-31 0:00 UTC));
+        ben.iter(|| datetime!(2019-12-31 0:00 UTC) - datetime!(2020-01-01 0:00 UTC));
+    }
+
+    fn std_sub(ben: &mut Bencher<'_>) {
+        let a = SystemTime::from(datetime!(2019-01-02 0:00 UTC));
+        let b = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let c = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+        let d = SystemTime::from(datetime!(2019-12-31 0:00 UTC));
+
+        ben.iter(|| a - datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| b - datetime!(2019-01-02 0:00 UTC));
+        ben.iter(|| c - datetime!(2019-12-31 0:00 UTC));
+        ben.iter(|| d - datetime!(2020-01-01 0:00 UTC));
+    }
+
+    fn sub_std(ben: &mut Bencher<'_>) {
+        let a = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let b = SystemTime::from(datetime!(2019-01-02 0:00 UTC));
+        let c = SystemTime::from(datetime!(2019-12-31 0:00 UTC));
+        let d = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+
+        ben.iter(|| datetime!(2019-01-02 0:00 UTC) - a);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) - c);
+        ben.iter(|| datetime!(2019-12-31 0:00 UTC) - d);
+    }
+
+    fn eq_std(ben: &mut Bencher<'_>) {
+        let a = OffsetDateTime::now_utc();
+        let b = SystemTime::from(a);
+        ben.iter(|| a == b);
+    }
+
+    fn std_eq(ben: &mut Bencher<'_>) {
+        let a = OffsetDateTime::now_utc();
+        let b = SystemTime::from(a);
+        ben.iter(|| b == a);
+    }
+
+    fn ord_std(ben: &mut Bencher<'_>) {
+        let a = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let b = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+        let c = SystemTime::from(datetime!(2019-02-01 0:00 UTC));
+        let d = SystemTime::from(datetime!(2019-01-02 0:00 UTC));
+        let e = SystemTime::from(datetime!(2019-01-01 1:00:00 UTC));
+        let f = SystemTime::from(datetime!(2019-01-01 0:01:00 UTC));
+        let g = SystemTime::from(datetime!(2019-01-01 0:00:01 UTC));
+        let h = SystemTime::from(datetime!(2019-01-01 0:00:00.001 UTC));
+        let i = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let j = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let k = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let l = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let m = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let n = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let o = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) == a);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < b);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < c);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < d);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < e);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < f);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < g);
+        ben.iter(|| datetime!(2019-01-01 0:00 UTC) < h);
+        ben.iter(|| datetime!(2020-01-01 0:00 UTC) > i);
+        ben.iter(|| datetime!(2019-02-01 0:00 UTC) > j);
+        ben.iter(|| datetime!(2019-01-02 0:00 UTC) > k);
+        ben.iter(|| datetime!(2019-01-01 1:00:00 UTC) > l);
+        ben.iter(|| datetime!(2019-01-01 0:01:00 UTC) > m);
+        ben.iter(|| datetime!(2019-01-01 0:00:01 UTC) > n);
+        ben.iter(|| datetime!(2019-01-01 0:00:00.000_000_001 UTC) > o);
+    }
+
+    fn std_ord(ben: &mut Bencher<'_>) {
+        let a = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let b = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let c = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let d = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let e = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let f = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let g = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let h = SystemTime::from(datetime!(2019-01-01 0:00 UTC));
+        let i = SystemTime::from(datetime!(2020-01-01 0:00 UTC));
+        let j = SystemTime::from(datetime!(2019-02-01 0:00 UTC));
+        let k = SystemTime::from(datetime!(2019-01-02 0:00 UTC));
+        let l = SystemTime::from(datetime!(2019-01-01 1:00:00 UTC));
+        let m = SystemTime::from(datetime!(2019-01-01 0:01:00 UTC));
+        let n = SystemTime::from(datetime!(2019-01-01 0:00:01 UTC));
+        let o = SystemTime::from(datetime!(2019-01-01 0:00:00.001 UTC));
+
+        ben.iter(|| a == datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| b < datetime!(2020-01-01 0:00 UTC));
+        ben.iter(|| c < datetime!(2019-02-01 0:00 UTC));
+        ben.iter(|| d < datetime!(2019-01-02 0:00 UTC));
+        ben.iter(|| e < datetime!(2019-01-01 1:00:00 UTC));
+        ben.iter(|| f < datetime!(2019-01-01 0:01:00 UTC));
+        ben.iter(|| g < datetime!(2019-01-01 0:00:01 UTC));
+        ben.iter(|| h < datetime!(2019-01-01 0:00:00.000_000_001 UTC));
+        ben.iter(|| i > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| j > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| k > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| l > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| m > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| n > datetime!(2019-01-01 0:00 UTC));
+        ben.iter(|| o > datetime!(2019-01-01 0:00 UTC));
+    }
+
+    fn from_std(ben: &mut Bencher<'_>) {
+        let a = SystemTime::UNIX_EPOCH;
+        let b = SystemTime::UNIX_EPOCH - 1.std_days();
+        let c = SystemTime::UNIX_EPOCH + 1.std_days();
+        ben.iter(|| OffsetDateTime::from(a));
+        ben.iter(|| OffsetDateTime::from(b));
+        ben.iter(|| OffsetDateTime::from(c));
+    }
+
+    fn to_std(ben: &mut Bencher<'_>) {
+        let a = OffsetDateTime::UNIX_EPOCH;
+        let b = OffsetDateTime::UNIX_EPOCH + 1.days();
+        let c = OffsetDateTime::UNIX_EPOCH - 1.days();
+        ben.iter(|| SystemTime::from(a));
+        ben.iter(|| SystemTime::from(b));
+        ben.iter(|| SystemTime::from(c));
+    }
+}

vendor/time/benchmarks/parsing.rs

@@ -0,0 +1,230 @@
+use criterion::Bencher;
+use time::OffsetDateTime;
+use time::format_description::well_known::{Rfc2822, Rfc3339};
+use time::format_description::{Component, modifier};
+use time::parsing::Parsed;
+
+macro_rules! component {
+    ($name:ident {$($field:ident : $value:expr),* $(,)? }) => {{
+        const COMPONENT: Component = Component::$name({
+            #[allow(unused_mut, reason = "macro-generated code")]
+            let mut modifier = modifier::$name::default();
+            $(modifier.$field = $value;)*
+            modifier
+        });
+        COMPONENT
+    }};
+}
+
+setup_benchmark! {
+    "Parsing",
+
+    fn parse_component_year(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"2021", component!(Year {
+                padding: modifier::Padding::Zero,
+                repr: modifier::YearRepr::Full,
+                iso_week_based: false,
+                sign_is_mandatory: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"21", component!(Year {
+                padding: modifier::Padding::Zero,
+                repr: modifier::YearRepr::LastTwo,
+                iso_week_based: false,
+                sign_is_mandatory: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"2021", component!(Year {
+                padding: modifier::Padding::Zero,
+                repr: modifier::YearRepr::Full,
+                iso_week_based: true,
+                sign_is_mandatory: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"21", component!(Year {
+                padding: modifier::Padding::Zero,
+                repr: modifier::YearRepr::LastTwo,
+                iso_week_based: true,
+                sign_is_mandatory: false,
+            }))
+        });
+    }
+
+    fn parse_component_month(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b" 1", component!(Month {
+                padding: modifier::Padding::Space,
+                repr: modifier::MonthRepr::Numerical,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"Jan", component!(Month {
+                padding: modifier::Padding::None,
+                repr: modifier::MonthRepr::Short,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"January", component!(Month {
+                padding: modifier::Padding::None,
+                repr: modifier::MonthRepr::Long,
+            }))
+        });
+    }
+
+    fn parse_component_ordinal(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"012", component!(Ordinal {
+                padding: modifier::Padding::Zero,
+            }))
+        });
+    }
+
+    fn parse_component_weekday(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"Sun", component!(Weekday {
+                repr: modifier::WeekdayRepr::Short,
+                one_indexed: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"Sunday", component!(Weekday {
+                repr: modifier::WeekdayRepr::Long,
+                one_indexed: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"0", component!(Weekday {
+                repr: modifier::WeekdayRepr::Sunday,
+                one_indexed: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"1", component!(Weekday {
+                repr: modifier::WeekdayRepr::Sunday,
+                one_indexed: true,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"6", component!(Weekday {
+                repr: modifier::WeekdayRepr::Monday,
+                one_indexed: false,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"7", component!(Weekday {
+                repr: modifier::WeekdayRepr::Monday,
+                one_indexed: true,
+            }))
+        });
+    }
+
+    fn parse_component_week_number(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"2", component!(WeekNumber {
+                padding: modifier::Padding::None,
+                repr: modifier::WeekNumberRepr::Sunday,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"2", component!(WeekNumber {
+                padding: modifier::Padding::None,
+                repr: modifier::WeekNumberRepr::Monday,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"2", component!(WeekNumber {
+                padding: modifier::Padding::None,
+                repr: modifier::WeekNumberRepr::Iso,
+            }))
+        });
+    }
+
+    fn parse_component_subsecond(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| {
+            parsed.parse_component(b"1", component!(Subsecond {
+                digits: modifier::SubsecondDigits::One,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"12", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Two,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"123", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Three,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"1234", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Four,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"12345", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Five,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"123456", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Six,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"1234567", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Seven,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"12345678", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Eight,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"123456789", component!(Subsecond {
+                digits: modifier::SubsecondDigits::Nine,
+            }))
+        });
+        ben.iter(|| {
+            parsed.parse_component(b"123456789", component!(Subsecond {
+                digits: modifier::SubsecondDigits::OneOrMore,
+            }))
+        });
+    }
+
+    fn parse_component_unix_timestamp(ben: &mut Bencher<'_>) {
+        let mut parsed = Parsed::new();
+        ben.iter(|| parsed.parse_component(std::hint::black_box(b"1234567890"), component!(UnixTimestamp {})));
+    }
+
+    fn parse_rfc3339(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.1Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.12Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.1234Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.12345Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123456Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.1234567Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.12345678Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123456789Z", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123456789-01:02", &Rfc3339));
+        ben.iter(|| OffsetDateTime::parse("2021-01-02T03:04:05.123456789+01:02", &Rfc3339));
+    }
+
+    fn parse_rfc2822(ben: &mut Bencher<'_>) {
+        ben.iter(|| OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 +0000", &Rfc2822));
+        ben.iter(|| OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 +0607", &Rfc2822));
+        ben.iter(|| OffsetDateTime::parse("Sat, 02 Jan 2021 03:04:05 -0607", &Rfc2822));
+    }
+}

vendor/time/benchmarks/primitive_date_time.rs

@@ -0,0 +1,144 @@
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::{datetime, offset};
+
+setup_benchmark! {
+    "PrimitiveDateTime",
+
+    // All getters are trivially dispatched to the relevant field, and do not need to be benchmarked
+    // a second time.
+
+    fn assume_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00).assume_offset(offset!(UTC)));
+        ben.iter(|| datetime!(2019-01-01 0:00).assume_offset(offset!(-1)));
+    }
+
+    fn assume_utc(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00).assume_utc());
+    }
+
+    fn add_duration(ben: &mut Bencher<'_>) {
+        let a = 5.days();
+        let b = 1.days();
+        let c = 2.seconds();
+        let d = (-2).seconds();
+        let e = 1.hours();
+
+        ben.iter(|| datetime!(2019-01-01 0:00) + a);
+        ben.iter(|| datetime!(2019-12-31 0:00) + b);
+        ben.iter(|| datetime!(2019-12-31 23:59:59) + c);
+        ben.iter(|| datetime!(2020-01-01 0:00:01) + d);
+        ben.iter(|| datetime!(1999-12-31 23:00) + e);
+    }
+
+    fn add_std_duration(ben: &mut Bencher<'_>) {
+        let a = 5.std_days();
+        let b = 1.std_days();
+        let c = 2.std_seconds();
+
+        ben.iter(|| datetime!(2019-01-01 0:00) + a);
+        ben.iter(|| datetime!(2019-12-31 0:00) + b);
+        ben.iter(|| datetime!(2019-12-31 23:59:59) + c);
+    }
+
+    fn add_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn add_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_days();
+        let b = 1.std_seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00),
+            [
+                |datetime| *datetime += a,
+                |datetime| *datetime += b,
+            ]
+        );
+    }
+
+    fn sub_duration(ben: &mut Bencher<'_>) {
+        let a = 5.days();
+        let b = 1.days();
+        let c = 2.seconds();
+        let d = (-2).seconds();
+        let e = (-1).hours();
+
+        ben.iter(|| datetime!(2019-01-06 0:00) - a);
+        ben.iter(|| datetime!(2020-01-01 0:00) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00:01) - c);
+        ben.iter(|| datetime!(2019-12-31 23:59:59) - d);
+        ben.iter(|| datetime!(1999-12-31 23:00) - e);
+    }
+
+    fn sub_std_duration(ben: &mut Bencher<'_>) {
+        let a = 5.std_days();
+        let b = 1.std_days();
+        let c = 2.std_seconds();
+
+        ben.iter(|| datetime!(2019-01-06 0:00) - a);
+        ben.iter(|| datetime!(2020-01-01 0:00) - b);
+        ben.iter(|| datetime!(2020-01-01 0:00:01) - c);
+    }
+
+    fn sub_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.days();
+        let b = 1.seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn sub_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_days();
+        let b = 1.std_seconds();
+        iter_batched_ref!(
+            ben,
+            || datetime!(2019-01-01 0:00),
+            [
+                |datetime| *datetime -= a,
+                |datetime| *datetime -= b,
+            ]
+        );
+    }
+
+    fn sub_datetime(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-02 0:00) - datetime!(2019-01-01 0:00));
+        ben.iter(|| datetime!(2019-01-01 0:00) - datetime!(2019-01-02 0:00));
+        ben.iter(|| datetime!(2020-01-01 0:00) - datetime!(2019-12-31 0:00));
+        ben.iter(|| datetime!(2019-12-31 0:00) - datetime!(2020-01-01 0:00));
+    }
+
+    fn ord(ben: &mut Bencher<'_>) {
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2020-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-02-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-02 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 1:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:01)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00:01)));
+        ben.iter(|| datetime!(2019-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00:00.000_000_001)));
+        ben.iter(|| datetime!(2020-01-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-02-01 0:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-02 0:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 1:00).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:01).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00:01).partial_cmp(&datetime!(2019-01-01 0:00)));
+        ben.iter(|| datetime!(2019-01-01 0:00:00.000_000_001).partial_cmp(&datetime!(2019-01-01 0:00)));
+    }
+}

vendor/time/benchmarks/rand08.rs

@@ -0,0 +1,30 @@
+use criterion::Bencher;
+use rand08::rngs::mock::StepRng;
+use rand08::Rng;
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+macro_rules! bench_rand {
+    ($($name:ident : $type:ty),* $(,)?) => {
+        setup_benchmark! {
+            "Random",
+            $(fn $name(ben: &mut Bencher<'_>) {
+                iter_batched_ref!(
+                    ben,
+                    || StepRng::new(0, 1),
+                    [|rng| rng.r#gen::<$type>()]
+                );
+            })*
+        }
+    }
+}
+
+bench_rand![
+    time: Time,
+    date: Date,
+    utc_offset: UtcOffset,
+    primitive_date_time: PrimitiveDateTime,
+    offset_date_time: OffsetDateTime,
+    duration: Duration,
+    weekday: Weekday,
+    month: Month,
+];

vendor/time/benchmarks/rand09.rs

@@ -0,0 +1,61 @@
+use criterion::Bencher;
+use rand09::Rng;
+use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset, Weekday};
+
+macro_rules! bench_rand {
+    ($($name:ident : $type:ty),* $(,)?) => {
+        setup_benchmark! {
+            "Random",
+            $(fn $name(ben: &mut Bencher<'_>) {
+                iter_batched_ref!(
+                    ben,
+                    || StepRng::new(0, 1),
+                    [|rng| rng.random::<$type>()]
+                );
+            })*
+        }
+    }
+}
+
+bench_rand![
+    time: Time,
+    date: Date,
+    utc_offset: UtcOffset,
+    primitive_date_time: PrimitiveDateTime,
+    offset_date_time: OffsetDateTime,
+    duration: Duration,
+    weekday: Weekday,
+    month: Month,
+];
+
+// copy of `StepRng` from rand 0.8 to avoid deprecation warnings
+#[derive(Debug, Clone)]
+struct StepRng {
+    v: u64,
+    a: u64,
+}
+
+impl StepRng {
+    const fn new(initial: u64, increment: u64) -> Self {
+        Self {
+            v: initial,
+            a: increment,
+        }
+    }
+}
+
+impl rand09::RngCore for StepRng {
+    fn next_u32(&mut self) -> u32 {
+        self.next_u64() as u32
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        let res = self.v;
+        self.v = self.v.wrapping_add(self.a);
+        res
+    }
+
+    fn fill_bytes(&mut self, dst: &mut [u8]) {
+        rand09::rand_core::impls::fill_bytes_via_next(self, dst)
+    }
+}

vendor/time/benchmarks/time.rs

@@ -0,0 +1,271 @@
+use std::hint::black_box;
+
+use criterion::Bencher;
+use time::ext::{NumericalDuration, NumericalStdDuration};
+use time::macros::time;
+use time::Time;
+
+setup_benchmark! {
+    "Time",
+
+    fn from_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::from_hms(1, 2, 3));
+    }
+
+    fn from_hms_milli(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::from_hms_milli(1, 2, 3, 4));
+    }
+
+    fn from_hms_micro(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::from_hms_micro(1, 2, 3, 4));
+    }
+
+    fn from_hms_nano(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::from_hms_nano(1, 2, 3, 4));
+    }
+
+    fn as_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.as_hms());
+    }
+
+    fn as_hms_milli(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.as_hms_milli());
+    }
+
+    fn as_hms_micro(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.as_hms_micro());
+    }
+
+    fn as_hms_nano(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.as_hms_nano());
+    }
+
+    fn hour(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.hour());
+    }
+
+    fn minute(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.minute());
+    }
+
+    fn second(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.second());
+    }
+
+    fn millisecond(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.millisecond());
+    }
+
+    fn microsecond(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.microsecond());
+    }
+
+    fn nanosecond(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT.nanosecond());
+    }
+
+    fn add_duration(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = 1.seconds();
+        let c = 1.minutes();
+        let d = 1.hours();
+        let e = 1.days();
+        ben.iter(|| Time::MIDNIGHT + a);
+        ben.iter(|| Time::MIDNIGHT + b);
+        ben.iter(|| Time::MIDNIGHT + c);
+        ben.iter(|| Time::MIDNIGHT + d);
+        ben.iter(|| Time::MIDNIGHT + e);
+    }
+
+    fn add_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = 1.seconds();
+        let c = 1.minutes();
+        let d = 1.hours();
+        let e = 1.days();
+        iter_batched_ref!(
+            ben,
+            || Time::MIDNIGHT,
+            [
+                |time| *time += a,
+                |time| *time += b,
+                |time| *time += c,
+                |time| *time += d,
+                |time| *time += e,
+            ]
+        );
+    }
+
+    fn sub_duration(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = 1.seconds();
+        let c = 1.minutes();
+        let d = 1.hours();
+        let e = 1.days();
+        ben.iter(|| Time::MIDNIGHT - a);
+        ben.iter(|| Time::MIDNIGHT - b);
+        ben.iter(|| Time::MIDNIGHT - c);
+        ben.iter(|| Time::MIDNIGHT - d);
+        ben.iter(|| Time::MIDNIGHT - e);
+    }
+
+    fn sub_assign_duration(ben: &mut Bencher<'_>) {
+        let a = 1.milliseconds();
+        let b = 1.seconds();
+        let c = 1.minutes();
+        let d = 1.hours();
+        let e = 1.days();
+        iter_batched_ref!(
+            ben,
+            || Time::MIDNIGHT,
+            [
+                |time| *time -= a,
+                |time| *time -= b,
+                |time| *time -= c,
+                |time| *time -= d,
+                |time| *time -= e,
+            ]
+        );
+    }
+
+    fn add_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_milliseconds();
+        let b = 1.std_seconds();
+        let c = 1.std_minutes();
+        let d = 1.std_hours();
+        let e = 1.std_days();
+        ben.iter(|| Time::MIDNIGHT + a);
+        ben.iter(|| Time::MIDNIGHT + b);
+        ben.iter(|| Time::MIDNIGHT + c);
+        ben.iter(|| Time::MIDNIGHT + d);
+        ben.iter(|| Time::MIDNIGHT + e);
+    }
+
+    fn add_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_milliseconds();
+        let b = 1.std_seconds();
+        let c = 1.std_minutes();
+        let d = 1.std_hours();
+        let e = 1.std_days();
+        iter_batched_ref!(
+            ben,
+            || Time::MIDNIGHT,
+            [
+                |time| *time += a,
+                |time| *time += b,
+                |time| *time += c,
+                |time| *time += d,
+                |time| *time += e,
+            ]
+        );
+    }
+
+    fn sub_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_milliseconds();
+        let b = 1.std_seconds();
+        let c = 1.std_minutes();
+        let d = 1.std_hours();
+        let e = 1.std_days();
+        ben.iter(|| Time::MIDNIGHT - a);
+        ben.iter(|| Time::MIDNIGHT - b);
+        ben.iter(|| Time::MIDNIGHT - c);
+        ben.iter(|| Time::MIDNIGHT - d);
+        ben.iter(|| Time::MIDNIGHT - e);
+    }
+
+    fn sub_assign_std_duration(ben: &mut Bencher<'_>) {
+        let a = 1.std_milliseconds();
+        let b = 1.std_seconds();
+        let c = 1.std_minutes();
+        let d = 1.std_hours();
+        let e = 1.std_days();
+        iter_batched_ref!(
+            ben,
+            || Time::MIDNIGHT,
+            [
+                |time| *time -= a,
+                |time| *time -= b,
+                |time| *time -= c,
+                |time| *time -= d,
+                |time| *time -= e,
+            ]
+        );
+    }
+
+    fn sub_time(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT - time!(0:00:01));
+        ben.iter(|| time!(1:00) - Time::MIDNIGHT);
+        ben.iter(|| time!(1:00) - time!(0:00:01));
+    }
+
+    fn ordering(ben: &mut Bencher<'_>) {
+        ben.iter(|| Time::MIDNIGHT < time!(0:00:00.000_000_001));
+        ben.iter(|| Time::MIDNIGHT < time!(0:00:01));
+        ben.iter(|| time!(12:00) > time!(11:00));
+        ben.iter(|| Time::MIDNIGHT == time!(0:00:00.000_000_001));
+    }
+
+    fn sort_align_8(ben: &mut Bencher<'_>) {
+        ben.iter_batched_ref(
+            || {
+                #[repr(C,align(8))]
+                struct Padder {
+                    arr: [Time;4096],
+                }
+                let mut res = Padder {
+                    arr: [Time::MIDNIGHT;4096]
+                };
+                let mut last = Time::MIDNIGHT;
+                let mut last_hour = 0;
+                for t in &mut res.arr {
+                    *t = last;
+                    t.replace_hour(last_hour).expect("failed to replace hour");
+                    last += 997.std_milliseconds();
+                    last_hour = (last_hour + 5) % 24;
+                }
+                res.arr.sort_unstable_by_key(|t|
+                    (t.nanosecond(),t.second(),t.minute(),t.hour())
+                );
+                res
+            },
+            |v| black_box(v).arr.sort_unstable(),
+            criterion::BatchSize::SmallInput
+        )
+    }
+
+    fn sort_align_4(ben: &mut Bencher<'_>) {
+        ben.iter_batched_ref(
+            || {
+                #[repr(C,align(8))]
+                struct Padder {
+                    pad: u32,
+                    arr: [Time;4096],
+                }
+                let mut res = Padder {
+                    pad: 0,
+                    arr: [Time::MIDNIGHT;4096]
+                };
+                let mut last = Time::MIDNIGHT;
+                let mut last_hour = 0;
+                for t in &mut res.arr {
+                    *t = last;
+                    t.replace_hour(last_hour).expect("failed to replace hour");
+                    last += 997.std_milliseconds();
+                    last_hour = (last_hour + 5) % 24;
+                }
+                res.arr.sort_unstable_by_key(|t|
+                    (t.nanosecond(),t.second(),t.minute(),t.hour())
+                );
+                res
+            },
+            |v| black_box(v).arr.sort_unstable(),
+            criterion::BatchSize::SmallInput
+        )
+    }
+
+    fn duration_until(ben: &mut Bencher<'_>) {
+        let a = black_box(time!(1:02:03.004_005_006));
+        let b = black_box(time!(4:05:06.007_008_009));
+        ben.iter(|| black_box(a.duration_until(b)));
+    }
+}

vendor/time/benchmarks/utc_date_time.rs

@@ -0,0 +1,12 @@
+use std::hint::black_box;
+
+use criterion::Bencher;
+use time::macros::{offset, utc_datetime};
+
+setup_benchmark! {
+    "UtcDateTime",
+
+    fn to_offset(ben: &mut Bencher<'_>) {
+        ben.iter(|| black_box(utc_datetime!(2000-01-01 0:00)).to_offset(black_box(offset!(-5))));
+    }
+}

vendor/time/benchmarks/utc_offset.rs

@@ -0,0 +1,58 @@
+use criterion::Bencher;
+use time::{OffsetDateTime, UtcOffset};
+
+setup_benchmark! {
+    "UtcOffset",
+
+    fn from_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::from_hms(0, 0, 0));
+    }
+
+    fn from_whole_seconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::from_whole_seconds(0));
+    }
+
+    fn as_hms(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.as_hms());
+    }
+
+    fn whole_hours(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.whole_hours());
+    }
+
+    fn whole_minutes(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.whole_minutes());
+    }
+
+    fn minutes_past_hour(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.minutes_past_hour());
+    }
+
+    fn whole_seconds(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.whole_seconds());
+    }
+
+    fn seconds_past_minute(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.seconds_past_minute());
+    }
+
+    fn is_utc(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.is_utc());
+    }
+
+    fn is_positive(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.is_positive());
+    }
+
+    fn is_negative(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::UTC.is_negative());
+    }
+
+    fn local_offset_at(ben: &mut Bencher<'_>) {
+        ben.iter(|| UtcOffset::local_offset_at(OffsetDateTime::UNIX_EPOCH));
+    }
+
+    fn current_local_offset(ben: &mut Bencher<'_>) {
+        ben.iter(UtcOffset::current_local_offset);
+    }
+}

vendor/time/benchmarks/util.rs

@@ -0,0 +1,54 @@
+use std::hint::black_box as bb;
+use std::sync::LazyLock;
+
+use criterion::Bencher;
+use time::util;
+
+/// Generate a representative sample of all years.
+fn representative_years() -> [i32; 800] {
+    static DATES: LazyLock<[i32; 800]> = LazyLock::new(|| {
+        let mut years = [0; _];
+        for year in -400..400 {
+            years[(year + 400) as usize] = year;
+        }
+        crate::shuffle(years)
+    });
+
+    *DATES
+}
+
+setup_benchmark! {
+    "Utils",
+
+    fn noop(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for i in representative_years() {
+                let _ = bb(i);
+            }
+        });
+    }
+
+    fn is_leap_year(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for year in representative_years() {
+                let _ = bb(util::is_leap_year(bb(year)));
+            }
+        });
+    }
+
+    fn days_in_year(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for year in representative_years() {
+                let _ = bb(util::days_in_year(bb(year)));
+            }
+        });
+    }
+
+    fn weeks_in_year(ben: &mut Bencher<'_>) {
+        ben.iter(|| {
+            for year in representative_years() {
+                let _ = bb(util::weeks_in_year(bb(year)));
+            }
+        });
+    }
+}

vendor/time/benchmarks/weekday.rs

@@ -0,0 +1,81 @@
+use criterion::Bencher;
+use time::Weekday::*;
+
+setup_benchmark! {
+    "Weekday",
+
+    fn previous(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.previous());
+        ben.iter(|| Monday.previous());
+        ben.iter(|| Tuesday.previous());
+        ben.iter(|| Wednesday.previous());
+        ben.iter(|| Thursday.previous());
+        ben.iter(|| Friday.previous());
+        ben.iter(|| Saturday.previous());
+    }
+
+    fn next(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.next());
+        ben.iter(|| Monday.next());
+        ben.iter(|| Tuesday.next());
+        ben.iter(|| Wednesday.next());
+        ben.iter(|| Thursday.next());
+        ben.iter(|| Friday.next());
+        ben.iter(|| Saturday.next());
+    }
+
+    fn nth(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.nth_next(0));
+        ben.iter(|| Sunday.nth_next(1));
+        ben.iter(|| Sunday.nth_next(2));
+        ben.iter(|| Sunday.nth_next(3));
+        ben.iter(|| Sunday.nth_next(4));
+        ben.iter(|| Sunday.nth_next(5));
+        ben.iter(|| Sunday.nth_next(6));
+
+        ben.iter(|| Sunday.nth_next(7));
+        ben.iter(|| Sunday.nth_next(u8::MAX));
+        ben.iter(|| Monday.nth_next(7));
+        ben.iter(|| Monday.nth_next(u8::MAX));
+    }
+
+    fn number_from_monday(ben: &mut Bencher<'_>) {
+        ben.iter(|| Monday.number_from_monday());
+        ben.iter(|| Tuesday.number_from_monday());
+        ben.iter(|| Wednesday.number_from_monday());
+        ben.iter(|| Thursday.number_from_monday());
+        ben.iter(|| Friday.number_from_monday());
+        ben.iter(|| Saturday.number_from_monday());
+        ben.iter(|| Sunday.number_from_monday());
+    }
+
+    fn number_from_sunday(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.number_from_sunday());
+        ben.iter(|| Monday.number_from_sunday());
+        ben.iter(|| Tuesday.number_from_sunday());
+        ben.iter(|| Wednesday.number_from_sunday());
+        ben.iter(|| Thursday.number_from_sunday());
+        ben.iter(|| Friday.number_from_sunday());
+        ben.iter(|| Saturday.number_from_sunday());
+    }
+
+    fn number_days_from_monday(ben: &mut Bencher<'_>) {
+        ben.iter(|| Monday.number_days_from_monday());
+        ben.iter(|| Tuesday.number_days_from_monday());
+        ben.iter(|| Wednesday.number_days_from_monday());
+        ben.iter(|| Thursday.number_days_from_monday());
+        ben.iter(|| Friday.number_days_from_monday());
+        ben.iter(|| Saturday.number_days_from_monday());
+        ben.iter(|| Sunday.number_days_from_monday());
+    }
+
+    fn number_days_from_sunday(ben: &mut Bencher<'_>) {
+        ben.iter(|| Sunday.number_days_from_sunday());
+        ben.iter(|| Monday.number_days_from_sunday());
+        ben.iter(|| Tuesday.number_days_from_sunday());
+        ben.iter(|| Wednesday.number_days_from_sunday());
+        ben.iter(|| Thursday.number_days_from_sunday());
+        ben.iter(|| Friday.number_days_from_sunday());
+        ben.iter(|| Saturday.number_days_from_sunday());
+    }
+}