Add Writeable getters for some types, use in FFI

Author: Manishearth

Cargo.lock

@@ -17,6 +17,7 @@ use crate::{
 use alloc::{format, string::String};
 use core::{cmp::Ordering, str::FromStr};
 use icu_calendar::AnyCalendarKind;
+use writeable::Writeable;
 
 use super::{
     calendar::month_to_month_code,
@@ -679,6 +680,13 @@ impl PlainDate {
 
     #[inline]
     pub fn to_ixdtf_string(&self, display_calendar: DisplayCalendar) -> String {
+        self.to_ixdtf_writeable(display_calendar)
+            .write_to_string()
+            .into()
+    }
+
+    #[inline]
+    pub fn to_ixdtf_writeable(&self, display_calendar: DisplayCalendar) -> impl Writeable + '_ {
         IxdtfStringBuilder::default()
             .with_date(self.iso)
             .with_calendar(self.calendar.identifier(), display_calendar)

src/builtins/core/date.rs

@@ -20,6 +20,7 @@ use crate::{
 use alloc::string::String;
 use core::{cmp::Ordering, str::FromStr};
 use tinystr::TinyAsciiStr;
+use writeable::Writeable;
 
 /// A partial PlainDateTime record
 #[derive(Debug, Default, Clone)]
@@ -806,11 +807,11 @@ impl PlainDateTime {
         Ok(PlainTime::new_unchecked(self.iso.time))
     }
 
-    pub fn to_ixdtf_string(
+    pub fn to_ixdtf_writeable(
         &self,
         options: ToStringRoundingOptions,
         display_calendar: DisplayCalendar,
-    ) -> TemporalResult<String> {
+    ) -> TemporalResult<impl Writeable + '_> {
         let resolved_options = options.resolve()?;
         let result = self
             .iso
@@ -820,12 +821,20 @@ impl PlainDateTime {
         if !result.is_within_limits() {
             return Err(TemporalError::range().with_message("DateTime is not within valid limits."));
         }
-        let ixdtf_string = IxdtfStringBuilder::default()
+        let builder = IxdtfStringBuilder::default()
             .with_date(result.date)
             .with_time(result.time, resolved_options.precision)
-            .with_calendar(self.calendar.identifier(), display_calendar)
-            .build();
-        Ok(ixdtf_string)
+            .with_calendar(self.calendar.identifier(), display_calendar);
+        Ok(builder)
+    }
+
+    pub fn to_ixdtf_string(
+        &self,
+        options: ToStringRoundingOptions,
+        display_calendar: DisplayCalendar,
+    ) -> TemporalResult<String> {
+        self.to_ixdtf_writeable(options, display_calendar)
+            .map(|x| x.write_to_string().into())
     }
 }
 

src/builtins/core/datetime.rs

@@ -91,6 +91,16 @@ impl<'a> IxdtfStringBuilder<'a> {
     }
 }
 
+impl<'a> Writeable for IxdtfStringBuilder<'a> {
+    fn write_to<W: core::fmt::Write + ?Sized>(&self, sink: &mut W) -> core::fmt::Result {
+        self.inner.write_to(sink)
+    }
+
+    fn writeable_length_hint(&self) -> LengthHint {
+        self.inner.writeable_length_hint()
+    }
+}
+
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Precision {
     #[default]

src/parsers.rs

@@ -24,6 +24,7 @@ num-traits.workspace = true
 temporal_rs = { workspace = true, default-features = false }
 icu_calendar = { version = "2.0.2", default-features = false }
 icu_locale = { version = "2.0.0" }
+writeable = "0.6.1"
 
 [features]
 compiled_data = ["temporal_rs/compiled_data"]

temporal_capi/Cargo.toml

@@ -19,6 +19,7 @@ pub mod ffi {
     use core::fmt::Write;
     use diplomat_runtime::{DiplomatOption, DiplomatStrSlice, DiplomatWrite};
     use diplomat_runtime::{DiplomatStr, DiplomatStr16};
+    use writeable::Writeable;
 
     use core::str::FromStr;
 
@@ -277,10 +278,10 @@ pub mod ffi {
             display_calendar: DisplayCalendar,
             write: &mut DiplomatWrite,
         ) {
-            // TODO this double-allocates, an API returning a Writeable or impl Write would be better
-            let string = self.0.to_ixdtf_string(display_calendar.into());
-            // throw away the error, this should always succeed
-            let _ = write.write_str(&string);
+            let writeable = self.0.to_ixdtf_writeable(display_calendar.into());
+            // This can only fail in cases where the DiplomatWriteable is capped, we
+            // don't care about that.
+            let _ = writeable.write_to(write);
         }
     }
 }

temporal_capi/src/plain_date.rs

@@ -20,6 +20,7 @@ pub mod ffi {
     use core::str::FromStr;
     use diplomat_runtime::DiplomatWrite;
     use diplomat_runtime::{DiplomatStr, DiplomatStr16};
+    use writeable::Writeable;
 
     #[diplomat::opaque]
     pub struct PlainDateTime(pub(crate) temporal_rs::PlainDateTime);
@@ -320,11 +321,13 @@ pub mod ffi {
             write: &mut DiplomatWrite,
         ) -> Result<(), TemporalError> {
             // TODO this double-allocates, an API returning a Writeable or impl Write would be better
-            let string = self
+            let writeable = self
                 .0
-                .to_ixdtf_string(options.into(), display_calendar.into())?;
-            // throw away the error, this should always succeed
-            let _ = write.write_str(&string);
+                .to_ixdtf_writeable(options.into(), display_calendar.into())?;
+
+            // This can only fail in cases where the DiplomatWriteable is capped, we
+            // don't care about that.
+            let _ = writeable.write_to(write);
             Ok(())
         }
     }