[workerd-cxx] kj::Date support (#64)

represented as `KjDate` object on rust side.

Author: mikea

.github/workflows/ci.yml

@@ -38,7 +38,7 @@ jobs:
         if: matrix.os.name == 'macos'
         run: sudo xcode-select -s "/Applications/Xcode_16.3.app"
       - run: bazel --version
-      - run: bazel test ... --verbose_failures ${{matrix.os.name == 'macos' && '--xcode_version_config=tools/bazel:github_actions_xcodes' || ''}}
+      - run: bazel test ... --verbose_failures --test_output=errors ${{matrix.os.name == 'macos' && '--xcode_version_config=tools/bazel:github_actions_xcodes' || ''}}
 
 
   clippy:
@@ -57,7 +57,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - run: sudo apt-get install lld
-      - run: bazel test --config=asan ... --verbose_failures
+      - run: bazel test --config=asan ... --verbose_failures --test_output=errors
 
   clang-tidy:
     name: Clang Tidy

README.md

@@ -36,6 +36,7 @@ The following smart pointers can be used in ffi layers:
 ### KJ Data Structures Integration
 
 - `kj::Maybe<T>` - corresponds to `kj_rs::KjMaybe<T>`.
+- `kj::Date` - corresponds to `kj_rs::KjDate`.
 
 ### KJ/Rust conversion layer
 

gen/src/include.rs

@@ -43,6 +43,7 @@ pub struct Includes<'a> {
     pub basetsd: bool,
     pub sys_types: bool,
     pub content: Content<'a>,
+    pub kj_date: bool,
     pub kj_rs: bool,
     pub jsg: bool,
 }
@@ -107,6 +108,7 @@ pub fn write(out: &mut OutFile) {
         vector,
         basetsd,
         sys_types,
+        kj_date,
         kj_rs,
         jsg,
         content: _,
@@ -190,6 +192,9 @@ pub fn write(out: &mut OutFile) {
         writeln!(out, "#include <ranges>");
         writeln!(out, "#endif");
     }
+    if kj_date && !cxx_header {
+        writeln!(out, "#include \"kj-rs/date.h\"");
+    }
     if kj_rs && !cxx_header {
         writeln!(out, "#include \"kj-rs/kj-rs.h\"");
     }

gen/src/write.rs

@@ -240,6 +240,9 @@ fn pick_includes_and_builtins(out: &mut OutFile, apis: &[Api]) {
             | Type::KjArc(_) => {
                 out.include.kj_rs = true;
             }
+            Type::KjDate(_) => {
+                out.include.kj_date = true;
+            }
         }
     }
 }
@@ -760,15 +763,7 @@ fn write_cxx_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
         if i > 0 || efn.receiver.is_some() {
             write!(out, ", ");
         }
-        if arg.ty == RustString {
-            write_type_space(out, &arg.ty);
-            write!(out, "const *{}", arg.name.cxx);
-        } else if let Type::RustVec(_) = arg.ty {
-            write_type_space(out, &arg.ty);
-            write!(out, "const *{}", arg.name.cxx);
-        } else {
-            write_extern_arg(out, arg);
-        }
+        write_cxx_shim_sig_arg(out, arg);
     }
     let indirect_return = indirect_return(efn, out.types);
     if indirect_return {
@@ -840,6 +835,9 @@ fn write_cxx_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
             write_type(out, ty);
             write!(out, ">::repr(");
         }
+        Some(Type::KjDate(_)) => {
+            write!(out, "::kj_rs::repr::toNanos(");
+        }
         _ => {}
     }
     match &efn.receiver {
@@ -850,34 +848,13 @@ fn write_cxx_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
         if i > 0 {
             write!(out, ", ");
         }
-        if let Type::RustBox(_) = &arg.ty {
-            write_type(out, &arg.ty);
-            write!(out, "::from_raw({})", arg.name.cxx);
-        } else if let Type::UniquePtr(_) = &arg.ty {
-            write_type(out, &arg.ty);
-            write!(out, "({})", arg.name.cxx);
-        } else if arg.ty == RustString {
-            out.builtin.unsafe_bitcopy = true;
-            write!(
-                out,
-                "::rust::String(::rust::unsafe_bitcopy, *{})",
-                arg.name.cxx,
-            );
-        } else if let Type::RustVec(_) = arg.ty {
-            out.builtin.unsafe_bitcopy = true;
-            write_type(out, &arg.ty);
-            write!(out, "(::rust::unsafe_bitcopy, *{})", arg.name.cxx);
-        } else if out.types.needs_indirect_abi(&arg.ty) {
-            out.include.utility = true;
-            write!(out, "::std::move(*{})", arg.name.cxx);
-        } else {
-            write!(out, "{}", arg.name.cxx);
-        }
+        write_cxx_shim_arg(out, arg);
     }
     write!(out, ")");
     match &efn.ret {
         Some(Type::RustBox(_)) => write!(out, ".into_raw()"),
         Some(Type::UniquePtr(_)) => write!(out, ".release()"),
+        Some(Type::KjDate(_)) => write!(out, ")"),
         Some(Type::Str(_) | Type::SliceRef(_)) if !indirect_return => write!(out, ")"),
         _ => {}
     }
@@ -898,6 +875,63 @@ fn write_cxx_function_shim<'a>(out: &mut OutFile<'a>, efn: &'a ExternFn) {
     out.end_block(Block::ExternC);
 }
 
+/// Write argument as part of cxx function call inside of cxx shim
+fn write_cxx_shim_arg(out: &mut OutFile, arg: &Var) {
+    match &arg.ty {
+        Type::RustBox(_) => {
+            write_type(out, &arg.ty);
+            write!(out, "::from_raw({})", arg.name.cxx);
+        }
+        Type::UniquePtr(_) => {
+            write_type(out, &arg.ty);
+            write!(out, "({})", arg.name.cxx);
+        }
+        Type::RustVec(_) => {
+            out.builtin.unsafe_bitcopy = true;
+            write_type(out, &arg.ty);
+            write!(out, "(::rust::unsafe_bitcopy, *{})", arg.name.cxx);
+        }
+        Type::KjDate(_) => {
+            write!(out, "::kj_rs::repr::fromNanos({})", arg.name.cxx);
+        }
+        t if t == RustString => {
+            out.builtin.unsafe_bitcopy = true;
+            write!(
+                out,
+                "::rust::String(::rust::unsafe_bitcopy, *{})",
+                arg.name.cxx,
+            );
+        }
+        t if out.types.needs_indirect_abi(t) => {
+            out.include.utility = true;
+            write!(out, "::std::move(*{})", arg.name.cxx);
+        }
+        _ => {
+            write!(out, "{}", arg.name.cxx);
+        }
+    }
+}
+
+/// Write argument as part of cxx shim function signature
+fn write_cxx_shim_sig_arg(out: &mut OutFile, arg: &Var) {
+    match &arg.ty {
+        Type::RustVec(_) => {
+            write_type_space(out, &arg.ty);
+            write!(out, "const *{}", arg.name.cxx);
+        }
+        Type::KjDate(_) => {
+            write!(out, "::std::int64_t {}", arg.name.cxx);
+        }
+        t if t == RustString => {
+            write_type_space(out, &arg.ty);
+            write!(out, "const *{}", arg.name.cxx);
+        }
+        _ => {
+            write_extern_arg(out, arg);
+        }
+    }
+}
+
 fn write_function_pointer_trampoline(out: &mut OutFile, efn: &ExternFn, var: &Pair, f: &Signature) {
     let r_trampoline = mangle::r_trampoline(efn, var, out.types);
     let indirect_call = true;
@@ -1216,6 +1250,9 @@ fn write_extern_return_type_space(out: &mut OutFile, ty: &Option<Type>) {
             out.builtin.repr_fat = true;
             write!(out, "::rust::repr::Fat ");
         }
+        Some(Type::KjDate(_)) => {
+            write!(out, "::std::int64_t ");
+        }
         Some(ty) if out.types.needs_indirect_abi(ty) => write!(out, "void "),
         _ => write_return_type(out, ty),
     }
@@ -1341,6 +1378,7 @@ fn write_type(out: &mut OutFile, ty: &Type) {
             write!(out, ", {}>", &a.len);
         }
         Type::Void(_) => write!(out, "void"),
+        Type::KjDate(_) => write!(out, "::kj::Date"),
         Type::Future(ty) => {
             write!(out, "kj::Promise<");
             write_type(out, &ty.output);
@@ -1387,6 +1425,7 @@ fn write_space_after_type(out: &mut OutFile, ty: &Type) {
         | Type::WeakPtr(_)
         | Type::Str(_)
         | Type::KjMaybe(_)
+        | Type::KjDate(_)
         | Type::CxxVector(_)
         | Type::RustVec(_)
         | Type::SliceRef(_)

kj-rs/convert.h

@@ -268,7 +268,6 @@ struct RustCopy {
     return from(&ptr);
   }
 
-
   /// from<RustCopy>(rustSliceOfStrs) - Copy slice of strs to null-terminated KJ strings
   static kj::Array<kj::String> into(::rust::Slice<::rust::str> slice) {
     auto res = kj::heapArrayBuilder<kj::String>(slice.size());

kj-rs/date.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <kj/time.h>
+
+#include <cstdint>
+
+namespace kj_rs {
+namespace repr {
+
+inline std::int64_t toNanos(kj::Date date) {
+  return (date - kj::origin<kj::Date>()) / kj::NANOSECONDS;
+}
+
+inline kj::Date fromNanos(std::int64_t nanos) {
+  return kj::origin<kj::Date>() + (nanos * kj::NANOSECONDS);
+}
+
+}  // namespace repr
+}  // namespace kj_rs

kj-rs/date.rs

@@ -0,0 +1,126 @@
+use core::fmt;
+use std::time::{Duration, SystemTime};
+
+/// Represents a `kj::Date` from the KJ library.
+///
+/// Like C++ represents a point in time as nanoseconds since the Unix epoch (January 1, 1970 UTC).
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct KjDate {
+    /// Nanoseconds since Unix epoch (January 1, 1970 UTC)
+    nanoseconds: i64,
+}
+
+impl KjDate {
+    /// Creates a new `KjDate` representing the Unix epoch (January 1, 1970 UTC).
+    #[inline]
+    #[must_use]
+    pub const fn unix_epoch() -> Self {
+        Self { nanoseconds: 0 }
+    }
+
+    /// Returns the nanoseconds since Unix epoch.
+    /// This is the only public accessor method needed.
+    #[inline]
+    #[must_use]
+    pub const fn nanoseconds(&self) -> i64 {
+        self.nanoseconds
+    }
+}
+
+impl Default for KjDate {
+    /// Returns the Unix epoch as the default date.
+    fn default() -> Self {
+        Self::unix_epoch()
+    }
+}
+
+impl fmt::Debug for KjDate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "KjDate({:?})",
+            std::convert::Into::<SystemTime>::into(*self)
+        )
+    }
+}
+
+impl From<i64> for KjDate {
+    #[inline]
+    fn from(nanoseconds: i64) -> Self {
+        Self { nanoseconds }
+    }
+}
+
+impl From<KjDate> for i64 {
+    #[inline]
+    fn from(date: KjDate) -> Self {
+        date.nanoseconds
+    }
+}
+
+impl From<SystemTime> for KjDate {
+    fn from(time: SystemTime) -> Self {
+        match time.duration_since(std::time::UNIX_EPOCH) {
+            Ok(duration) => {
+                let nanoseconds = i64::try_from(duration.as_nanos()).unwrap_or(i64::MAX);
+                Self { nanoseconds }
+            }
+            Err(err) => {
+                let duration_before = err.duration();
+                let nanoseconds = -(i64::try_from(duration_before.as_nanos()).unwrap_or(i64::MAX));
+                Self { nanoseconds }
+            }
+        }
+    }
+}
+
+impl From<KjDate> for SystemTime {
+    fn from(date: KjDate) -> Self {
+        let duration =
+            Duration::from_nanos(u64::try_from(date.nanoseconds.abs()).unwrap_or(u64::MAX));
+
+        if date.nanoseconds >= 0 {
+            std::time::UNIX_EPOCH + duration
+        } else {
+            std::time::UNIX_EPOCH - duration
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_unix_epoch() {
+        let epoch = KjDate::unix_epoch();
+        assert_eq!(epoch.nanoseconds(), 0);
+    }
+
+    #[test]
+    fn test_from_nanoseconds() {
+        let date = KjDate::from_nanoseconds(1000000000);
+        assert_eq!(date.nanoseconds(), 1000000000);
+    }
+
+    #[test]
+    fn test_ordering() {
+        let earlier = KjDate::from_nanoseconds(1000);
+        let later = KjDate::from_nanoseconds(2000);
+        assert!(earlier < later);
+    }
+
+    #[test]
+    fn test_default() {
+        let default_date = KjDate::default();
+        assert_eq!(default_date, KjDate::unix_epoch());
+    }
+
+    #[test]
+    fn test_system_time_conversion() {
+        let date = KjDate::from_nanoseconds(1000000000);
+        let system_time = date.to_system_time();
+        let converted_back = KjDate::from(system_time);
+        assert_eq!(date, converted_back);
+    }
+}

kj-rs/lib.rs

@@ -3,6 +3,7 @@ use awaiter::WakerRef;
 
 pub use crate::ffi::KjWaker;
 pub use awaiter::PromiseAwaiter;
+pub use date::KjDate;
 pub use future::FuturePollStatus;
 pub use maybe::repr::KjMaybe;
 pub use own::repr::KjOwn;
@@ -11,9 +12,10 @@ pub use promise::KjPromiseNodeImpl;
 pub use promise::OwnPromiseNode;
 pub use promise::PromiseFuture;
 pub use promise::new_callbacks_promise_future;
-pub use repr::{KjArc, KjRc};
+pub use refcount::repr::{KjArc, KjRc};
 
 mod awaiter;
+mod date;
 mod future;
 pub mod maybe;
 mod own;