Compare datetimes with signed integers

Author: jhpratt

tests/offset_date_time.rs

@@ -602,6 +602,10 @@ fn ord() {
     let t1 = datetime!(2019-01-01 0:00 UTC);
     let t2 = datetime!(2019-01-01 0:00:00.000_000_001 UTC);
     assert!(t2 > t1);
+
+    let t1 = datetime!(-0001-01-01 0:00 UTC);
+    let t2 = datetime!(0001-01-01 0:00 UTC);
+    assert!(t2 > t1);
 }
 
 #[test]

tests/primitive_date_time.rs

@@ -596,6 +596,10 @@ fn ord() {
         datetime!(2019-01-01 0:00:00.000_000_001).partial_cmp(&datetime!(2019-01-01 0:00)),
         Some(Greater)
     );
+    assert_eq!(
+        datetime!(-0001-01-01 0:00).partial_cmp(&datetime!(0001-01-01 0:00)),
+        Some(Less)
+    );
 }
 
 #[test]

time/src/date.rs

@@ -58,11 +58,15 @@ pub struct Date {
 }
 
 impl Date {
-    /// Provide a representation of `Date` as a `u32`. This value can be used for equality, hashing,
+    /// Provide a representation of `Date` as a `i32`. This value can be used for equality, hashing,
     /// and ordering.
+    ///
+    /// **Note**: This value is explicitly signed, so do not cast this to or treat this as an
+    /// unsigned integer. Doing so will lead to incorrect results for values with differing
+    /// signs.
     #[inline]
-    pub(crate) const fn as_u32(self) -> u32 {
-        self.value.get() as u32
+    pub(crate) const fn as_i32(self) -> i32 {
+        self.value.get()
     }
 
     /// The Unix epoch: 1970-01-01

time/src/offset_date_time.rs

@@ -68,9 +68,12 @@ impl Hash for OffsetDateTime {
     }
 }
 
+/// **Note**: This value is explicitly signed, so do not cast this to or treat this as an
+/// unsigned integer. Doing so will lead to incorrect results for values with differing
+/// signs.
 #[inline]
-const fn raw_to_bits((year, ordinal, time): (i32, u16, Time)) -> u128 {
-    ((year as u128) << 74) | ((ordinal as u128) << 64) | (time.as_u64() as u128)
+const fn raw_to_bits((year, ordinal, time): (i32, u16, Time)) -> i128 {
+    ((year as i128) << 74) | ((ordinal as i128) << 64) | (time.as_u64() as i128)
 }
 
 impl OffsetDateTime {

time/src/primitive_date_time.rs

@@ -44,14 +44,14 @@ pub struct PrimitiveDateTime {
 impl Hash for PrimitiveDateTime {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.as_u128().hash(state);
+        self.as_i128().hash(state);
     }
 }
 
 impl PartialEq for PrimitiveDateTime {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        self.as_u128().eq(&other.as_u128())
+        self.as_i128().eq(&other.as_i128())
     }
 }
 
@@ -65,17 +65,21 @@ impl PartialOrd for PrimitiveDateTime {
 impl Ord for PrimitiveDateTime {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
-        self.as_u128().cmp(&other.as_u128())
+        self.as_i128().cmp(&other.as_i128())
     }
 }
 
 impl PrimitiveDateTime {
-    /// Provide a representation of `PrimitiveDateTime` as a `u128`. This value can be used for
+    /// Provide a representation of `PrimitiveDateTime` as a `i128`. This value can be used for
     /// equality, hashing, and ordering.
+    ///
+    /// **Note**: This value is explicitly signed, so do not cast this to or treat this as an
+    /// unsigned integer. Doing so will lead to incorrect results for values with differing
+    /// signs.
     #[inline]
-    const fn as_u128(self) -> u128 {
-        let time = self.time.as_u64() as u128;
-        let date = self.date.as_u32() as u128;
+    const fn as_i128(self) -> i128 {
+        let time = self.time.as_u64() as i128;
+        let date = self.date.as_i32() as i128;
         (date << 64) | time
     }