0.4.x: deprecate methods that have an _opt() alternative

README.md

@@ -49,7 +49,7 @@ if you want.
 Chrono inherently does not support an inaccurate or partial date and time representation.
 Any operation that can be ambiguous will return `None` in such cases.
 For example, "a month later" of 2014-01-30 is not well-defined
-and consequently `Utc.ymd(2014, 1, 30).with_month(2)` returns `None`.
+and consequently `Utc.ymd_opt(2014, 1, 30).unwrap().with_month(2)` returns `None`.
 
 Non ISO week handling is not yet supported.
 For now you can use the [chrono_ext](https://crates.io/crates/chrono_ext)

benches/chrono.rs

@@ -35,14 +35,14 @@ fn bench_datetime_from_str(c: &mut Criterion) {
 }
 
 fn bench_datetime_to_rfc2822(c: &mut Criterion) {
-    let pst = FixedOffset::east(8 * 60 * 60);
-    let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 84_660_000);
+    let pst = FixedOffset::east_opt(8 * 60 * 60).unwrap();
+    let dt = pst.ymd_opt(2018, 1, 11).unwrap().and_hms_nano_opt(10, 5, 13, 84_660_000).unwrap();
     c.bench_function("bench_datetime_to_rfc2822", |b| b.iter(|| black_box(dt).to_rfc2822()));
 }
 
 fn bench_datetime_to_rfc3339(c: &mut Criterion) {
-    let pst = FixedOffset::east(8 * 60 * 60);
-    let dt = pst.ymd(2018, 1, 11).and_hms_nano(10, 5, 13, 84_660_000);
+    let pst = FixedOffset::east_opt(8 * 60 * 60).unwrap();
+    let dt = pst.ymd_opt(2018, 1, 11).and_hms_nano_opt(10, 5, 13, 84_660_000).unwrap();
     c.bench_function("bench_datetime_to_rfc3339", |b| b.iter(|| black_box(dt).to_rfc3339()));
 }
 
@@ -90,7 +90,7 @@ fn num_days_from_ce_alt<Date: Datelike>(date: &Date) -> i32 {
 fn bench_num_days_from_ce(c: &mut Criterion) {
     let mut group = c.benchmark_group("num_days_from_ce");
     for year in &[1, 500, 2000, 2019] {
-        let d = NaiveDate::from_ymd(*year, 1, 1);
+        let d = NaiveDate::from_ymd_opt(*year, 1, 1).unwrap();
         group.bench_with_input(BenchmarkId::new("new", year), &d, |b, y| {
             b.iter(|| num_days_from_ce_alt(y))
         });

ci/core-test/src/lib.rs

@@ -3,5 +3,5 @@
 use chrono::{TimeZone, Utc};
 
 pub fn create_time() {
-    let _ = Utc.ymd(2019, 1, 1).and_hms(0, 0, 0);
+    let _ = Utc.ymd_opt(2019, 1, 1).unwrap().and_hms_opt(0, 0, 0).unwrap();
 }

src/date.rs

@@ -48,7 +48,7 @@ use crate::{Datelike, Weekday};
 ///
 /// - Once constructed as a full `DateTime`, [`DateTime::date`] and other associated
 ///   methods should return those for the original `Date`. For example, if `dt =
-///   tz.ymd(y,m,d).hms(h,n,s)` were valid, `dt.date() == tz.ymd(y,m,d)`.
+///   tz.ymd_opt(y,m,d).unwrap().hms(h,n,s)` were valid, `dt.date() == tz.ymd_opt(y,m,d).unwrap()`.
 ///
 /// - The date is timezone-agnostic up to one day (i.e. practically always),
 ///   so the local date and UTC date should be equal for most cases
@@ -93,6 +93,7 @@ impl<Tz: TimeZone> Date<Tz> {
     /// The offset in the current date is preserved.
     ///
     /// Panics on invalid hour, minute and/or second.
+    #[deprecated(since = "0.4.23", note = "Use and_hms_opt() instead")]
     #[inline]
     pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> DateTime<Tz> {
         self.and_hms_opt(hour, min, sec).expect("invalid time")
@@ -112,6 +113,7 @@ impl<Tz: TimeZone> Date<Tz> {
     /// The offset in the current date is preserved.
     ///
     /// Panics on invalid hour, minute, second and/or millisecond.
+    #[deprecated(since = "0.4.23", note = "Use and_hms_milli_opt() instead")]
     #[inline]
     pub fn and_hms_milli(&self, hour: u32, min: u32, sec: u32, milli: u32) -> DateTime<Tz> {
         self.and_hms_milli_opt(hour, min, sec, milli).expect("invalid time")
@@ -138,6 +140,7 @@ impl<Tz: TimeZone> Date<Tz> {
     /// The offset in the current date is preserved.
     ///
     /// Panics on invalid hour, minute, second and/or microsecond.
+    #[deprecated(since = "0.4.23", note = "Use and_hms_micro_opt() instead")]
     #[inline]
     pub fn and_hms_micro(&self, hour: u32, min: u32, sec: u32, micro: u32) -> DateTime<Tz> {
         self.and_hms_micro_opt(hour, min, sec, micro).expect("invalid time")
@@ -164,6 +167,7 @@ impl<Tz: TimeZone> Date<Tz> {
     /// The offset in the current date is preserved.
     ///
     /// Panics on invalid hour, minute, second and/or nanosecond.
+    #[deprecated(since = "0.4.23", note = "Use and_hms_nano_opt() instead")]
     #[inline]
     pub fn and_hms_nano(&self, hour: u32, min: u32, sec: u32, nano: u32) -> DateTime<Tz> {
         self.and_hms_nano_opt(hour, min, sec, nano).expect("invalid time")
@@ -188,6 +192,7 @@ impl<Tz: TimeZone> Date<Tz> {
     /// Makes a new `Date` for the next date.
     ///
     /// Panics when `self` is the last representable date.
+    #[deprecated(since = "0.4.23", note = "Use succ_opt() instead")]
     #[inline]
     pub fn succ(&self) -> Date<Tz> {
         self.succ_opt().expect("out of bound")
@@ -204,6 +209,7 @@ impl<Tz: TimeZone> Date<Tz> {
     /// Makes a new `Date` for the prior date.
     ///
     /// Panics when `self` is the first representable date.
+    #[deprecated(since = "0.4.23", note = "Use pred_opt() instead")]
     #[inline]
     pub fn pred(&self) -> Date<Tz> {
         self.pred_opt().expect("out of bound")
@@ -331,7 +337,7 @@ where
     /// ```rust
     /// use chrono::prelude::*;
     ///
-    /// let date_time: Date<Utc> = Utc.ymd(2017, 04, 02);
+    /// let date_time: Date<Utc> = Utc.ymd_opt(2017, 04, 02).unwrap();
     /// let formatted = format!("{}", date_time.format("%d/%m/%Y"));
     /// assert_eq!(formatted, "02/04/2017");
     /// ```
@@ -569,20 +575,20 @@ mod tests {
 
     #[test]
     fn test_date_add_assign() {
-        let naivedate = NaiveDate::from_ymd(2000, 1, 1);
+        let naivedate = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
         let date = Date::<Utc>::from_utc(naivedate, Utc);
         let mut date_add = date;
 
         date_add += Duration::days(5);
         assert_eq!(date_add, date + Duration::days(5));
 
-        let timezone = FixedOffset::east(60 * 60);
+        let timezone = FixedOffset::east_opt(60 * 60).unwrap();
         let date = date.with_timezone(&timezone);
         let date_add = date_add.with_timezone(&timezone);
 
         assert_eq!(date_add, date + Duration::days(5));
 
-        let timezone = FixedOffset::west(2 * 60 * 60);
+        let timezone = FixedOffset::west_opt(2 * 60 * 60).unwrap();
         let date = date.with_timezone(&timezone);
         let date_add = date_add.with_timezone(&timezone);
 
@@ -592,7 +598,7 @@ mod tests {
     #[test]
     #[cfg(feature = "clock")]
     fn test_date_add_assign_local() {
-        let naivedate = NaiveDate::from_ymd(2000, 1, 1);
+        let naivedate = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
 
         let date = Local.from_utc_date(&naivedate);
         let mut date_add = date;
@@ -603,20 +609,20 @@ mod tests {
 
     #[test]
     fn test_date_sub_assign() {
-        let naivedate = NaiveDate::from_ymd(2000, 1, 1);
+        let naivedate = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
         let date = Date::<Utc>::from_utc(naivedate, Utc);
         let mut date_sub = date;
 
         date_sub -= Duration::days(5);
         assert_eq!(date_sub, date - Duration::days(5));
 
-        let timezone = FixedOffset::east(60 * 60);
+        let timezone = FixedOffset::east_opt(60 * 60).unwrap();
         let date = date.with_timezone(&timezone);
         let date_sub = date_sub.with_timezone(&timezone);
 
         assert_eq!(date_sub, date - Duration::days(5));
 
-        let timezone = FixedOffset::west(2 * 60 * 60);
+        let timezone = FixedOffset::west_opt(2 * 60 * 60).unwrap();
         let date = date.with_timezone(&timezone);
         let date_sub = date_sub.with_timezone(&timezone);
 
@@ -626,7 +632,7 @@ mod tests {
     #[test]
     #[cfg(feature = "clock")]
     fn test_date_sub_assign_local() {
-        let naivedate = NaiveDate::from_ymd(2000, 1, 1);
+        let naivedate = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
 
         let date = Local.from_utc_date(&naivedate);
         let mut date_sub = date;