initial implementation of ToZonedDateTime, ToPlainDate, ToPlainTime (#244)

Fixes #149

Author: lockels

src/builtins/compiled/mod.rs

@@ -3,6 +3,7 @@
 mod duration;
 mod instant;
 mod now;
+mod plain_date_time;
 mod zoneddatetime;
 
 mod options {

src/builtins/compiled/plain_date_time.rs

@@ -0,0 +1,23 @@
+use crate::{
+    builtins::core::{PlainDateTime, ZonedDateTime},
+    builtins::TZ_PROVIDER,
+    options::Disambiguation,
+    TemporalError, TemporalResult, TimeZone,
+};
+
+impl PlainDateTime {
+    /// Returns a `ZonedDateTime` with the provided `PlainDateTime`, TimeZone` and
+    /// `Disambiguation`
+    /// Enable with the `compiled_data` feature flag.
+    pub fn to_zoned_date_time(
+        &self,
+        time_zone: &TimeZone,
+        disambiguation: Disambiguation,
+    ) -> TemporalResult<ZonedDateTime> {
+        let provider = TZ_PROVIDER
+            .lock()
+            .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
+
+        self.to_zoned_date_time_with_provider(time_zone, disambiguation, &*provider)
+    }
+}

src/builtins/core/datetime.rs

@@ -2,18 +2,19 @@
 
 use super::{
     duration::normalized::{NormalizedDurationRecord, NormalizedTimeDuration},
-    Duration, PartialDate, PartialTime, PlainDate, PlainTime,
+    Duration, PartialDate, PartialTime, PlainDate, PlainTime, ZonedDateTime,
 };
 use crate::{
     builtins::core::{calendar::Calendar, Instant},
     iso::{IsoDate, IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, DisplayCalendar,
-        ResolvedRoundingOptions, RoundingOptions, TemporalUnit, ToStringRoundingOptions, UnitGroup,
+        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, Disambiguation,
+        DisplayCalendar, ResolvedRoundingOptions, RoundingOptions, TemporalUnit,
+        ToStringRoundingOptions, UnitGroup,
     },
     parsers::{parse_date_time, IxdtfStringBuilder},
     primitive::FiniteF64,
-    provider::NeverProvider,
+    provider::{NeverProvider, TimeZoneProvider},
     temporal_assert, MonthCode, TemporalError, TemporalResult, TemporalUnwrap, TimeZone,
 };
 use alloc::string::String;
@@ -682,8 +683,33 @@ impl PlainDateTime {
         Ok(Self::new_unchecked(result, self.calendar.clone()))
     }
 
+    pub fn to_zoned_date_time_with_provider(
+        &self,
+        time_zone: &TimeZone,
+        disambiguation: Disambiguation,
+        provider: &impl TimeZoneProvider,
+    ) -> TemporalResult<ZonedDateTime> {
+        // 6. Let epochNs be ? GetEpochNanosecondsFor(timeZone, dateTime.[[ISODateTime]], disambiguation).
+        let epoch_ns = time_zone.get_epoch_nanoseconds_for(self.iso, disambiguation, provider)?;
+        // 7. Return ! CreateTemporalZonedDateTime(epochNs, timeZone, dateTime.[[Calendar]]).
+        Ok(ZonedDateTime::new_unchecked(
+            Instant::from(epoch_ns),
+            self.calendar.clone(),
+            time_zone.clone(),
+        ))
+    }
+
+    pub fn to_plain_date(&self) -> TemporalResult<PlainDate> {
+        // 3. Return ! CreateTemporalDate(dateTime.[[ISODateTime]].[[ISODate]], dateTime.[[Calendar]]).
+        Ok(PlainDate::new_unchecked(
+            self.iso.date,
+            self.calendar.clone(),
+        ))
+    }
+
     pub fn to_plain_time(&self) -> TemporalResult<PlainTime> {
-        Err(TemporalError::general("Not yet implemented."))
+        // 3. Return ! CreateTemporalTime(dateTime.[[ISODateTime]].[[Time]]).
+        Ok(PlainTime::new_unchecked(self.iso.time))
     }
 
     pub fn to_ixdtf_string(

temporal_capi/bindings/cpp/temporal_rs/PlainDateTime.d.hpp

@@ -12,7 +12,7 @@ pub mod ffi {
         ArithmeticOverflow, DifferenceSettings, DisplayCalendar, RoundingOptions,
         ToStringRoundingOptions,
     };
-    use crate::plain_date::ffi::PartialDate;
+    use crate::plain_date::ffi::{PartialDate, PlainDate};
     use crate::plain_time::ffi::{PartialTime, PlainTime};
     use diplomat_runtime::DiplomatWrite;
     use std::fmt::Write;
@@ -249,6 +249,13 @@ pub mod ffi {
                 .map_err(Into::into)
         }
 
+        pub fn to_plain_date(&self) -> Result<Box<PlainDate>, TemporalError> {
+            self.0
+                .to_plain_date()
+                .map(|x| Box::new(PlainDate(x)))
+                .map_err(Into::into)
+        }
+
         pub fn to_plain_time(&self) -> Result<Box<PlainTime>, TemporalError> {
             self.0
                 .to_plain_time()