Build out stubs for remaining unimplemented methods (#202)

Unimplemented methods not being stubbed came up today in the ICU4X call.
This implements stubs for the remaining unimplemented methods that I'm
currently aware of nobody working on (in order to minimize any conflicts
with ongoing work).

This PR also takes a stab at adding the `temporal_capi` methods.

CC: @Manishearth

Author: nekevss

src/builtins/compiled/duration.rs

@@ -1,6 +1,6 @@
 use crate::{
     builtins::TZ_PROVIDER,
-    options::{RelativeTo, RoundingOptions},
+    options::{RelativeTo, RoundingOptions, TemporalUnit},
     Duration, TemporalError, TemporalResult,
 };
 
@@ -39,4 +39,15 @@ impl Duration {
             .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
         self.compare_with_provider(two, relative_to, &*provider)
     }
+
+    pub fn total(
+        &self,
+        unit: TemporalUnit,
+        relative_to: Option<RelativeTo>,
+    ) -> TemporalResult<i64> {
+        let provider = TZ_PROVIDER
+            .lock()
+            .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
+        self.total_with_provider(unit, relative_to, &*provider)
+    }
 }

src/builtins/compiled/zoneddatetime.rs

@@ -268,6 +268,14 @@ impl ZonedDateTime {
         self.in_leap_year_with_provider(&*provider)
     }
 
+    // TODO: Update direction to correct option
+    pub fn get_time_zone_transition(&self, direction: bool) -> TemporalResult<Self> {
+        let provider = TZ_PROVIDER
+            .lock()
+            .map_err(|_| TemporalError::general("Unable to acquire lock"))?;
+        self.get_time_zone_transition_with_provider(direction, &*provider)
+    }
+
     /// Returns the hours in the day.
     ///
     /// Enable with the `compiled_data` feature flag.

src/builtins/core/datetime.rs

@@ -626,6 +626,10 @@ impl PlainDateTime {
         Ok(Self::new_unchecked(result, self.calendar.clone()))
     }
 
+    pub fn to_plain_time(&self) -> TemporalResult<PlainTime> {
+        Err(TemporalError::general("Not yet implemented."))
+    }
+
     pub fn to_ixdtf_string(
         &self,
         options: ToStringRoundingOptions,

src/builtins/core/duration.rs

@@ -692,6 +692,17 @@ impl Duration {
         }
     }
 
+    /// Returns the total of the `Duration`
+    pub fn total_with_provider(
+        &self,
+        _unit: TemporalUnit,
+        _relative_to: Option<RelativeTo>,
+        _provider: &impl TimeZoneProvider,
+    ) -> TemporalResult<i64> {
+        Err(TemporalError::general("Not yet implemented"))
+    }
+
+    /// Returns the `Duration` as a formatted string
     pub fn as_temporal_string(&self, options: ToStringRoundingOptions) -> TemporalResult<String> {
         if options.smallest_unit == Some(TemporalUnit::Hour)
             || options.smallest_unit == Some(TemporalUnit::Minute)

src/builtins/core/instant.rs

@@ -25,7 +25,7 @@ use num_traits::Euclid;
 
 use super::{
     duration::normalized::{NormalizedDurationRecord, NormalizedTimeDuration},
-    DateDuration,
+    DateDuration, ZonedDateTime,
 };
 
 const NANOSECONDS_PER_SECOND: i64 = 1_000_000_000;
@@ -234,6 +234,11 @@ impl Instant {
     pub fn epoch_nanoseconds(&self) -> i128 {
         self.as_i128()
     }
+
+    // TODO: May end up needing a provider API during impl
+    pub fn to_zoned_date_time_iso(&self, _time_zone: TimeZone) -> TemporalResult<ZonedDateTime> {
+        Err(TemporalError::general("Not yet implemented"))
+    }
 }
 
 // ==== Instant Provider API ====

src/builtins/core/month_day.rs

@@ -12,6 +12,8 @@ use crate::{
     Calendar, TemporalError, TemporalResult, TemporalUnwrap,
 };
 
+use super::{PartialDate, PlainDate};
+
 /// The native Rust implementation of `Temporal.PlainMonthDay`
 #[non_exhaustive]
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
@@ -49,6 +51,14 @@ impl PlainMonthDay {
         Ok(Self::new_unchecked(iso, calendar))
     }
 
+    pub fn with(
+        &self,
+        _partial: PartialDate,
+        _overflow: ArithmeticOverflow,
+    ) -> TemporalResult<Self> {
+        Err(TemporalError::general("Not yet implemented."))
+    }
+
     /// Returns the iso day value of `MonthDay`.
     #[inline]
     #[must_use]
@@ -90,6 +100,10 @@ impl PlainMonthDay {
         self.calendar.month_code(&self.iso)
     }
 
+    pub fn to_plain_date(&self) -> TemporalResult<PlainDate> {
+        Err(TemporalError::general("Not yet implemented"))
+    }
+
     pub fn to_ixdtf_string(&self, display_calendar: DisplayCalendar) -> String {
         let ixdtf = FormattableMonthDay {
             date: FormattableDate(self.iso_year(), self.iso_month(), self.iso.day),

src/builtins/core/year_month.rs

@@ -7,13 +7,13 @@ use tinystr::TinyAsciiStr;
 
 use crate::{
     iso::IsoDate,
-    options::{ArithmeticOverflow, DisplayCalendar},
+    options::{ArithmeticOverflow, DifferenceOperation, DifferenceSettings, DisplayCalendar},
     parsers::{FormattableCalendar, FormattableDate, FormattableYearMonth},
     utils::pad_iso_year,
     Calendar, TemporalError, TemporalResult, TemporalUnwrap,
 };
 
-use super::{Duration, PartialDate};
+use super::{Duration, PartialDate, PlainDate};
 
 /// The native Rust implementation of `Temporal.YearMonth`.
 #[non_exhaustive]
@@ -37,6 +37,40 @@ impl PlainYearMonth {
         Self { iso, calendar }
     }
 
+    /// Internal addition method for adding `Duration` to a `PlainYearMonth`
+    pub(crate) fn add_or_subtract_duration(
+        &self,
+        duration: &Duration,
+        overflow: ArithmeticOverflow,
+    ) -> TemporalResult<Self> {
+        // Potential TODO: update to current Temporal specification
+        let partial = PartialDate::try_from_year_month(self)?;
+
+        let mut intermediate_date = self.calendar().date_from_partial(&partial, overflow)?;
+
+        intermediate_date = intermediate_date.add_date(duration, Some(overflow))?;
+
+        let result_fields = PartialDate::default().with_fallback_date(&intermediate_date)?;
+
+        self.calendar()
+            .year_month_from_partial(&result_fields, overflow)
+    }
+
+    /// The internal difference operation of `PlainYearMonth`.
+    pub(crate) fn diff(
+        &self,
+        _op: DifferenceOperation,
+        _other: &Self,
+        _settings: DifferenceSettings,
+    ) -> TemporalResult<Duration> {
+        // TODO: implement
+        Err(TemporalError::general("Not yet implemented"))
+    }
+}
+
+// ==== Public method implementations ====
+
+impl PlainYearMonth {
     /// Creates a new valid `YearMonth`.
     #[inline]
     pub fn new_with_overflow(
@@ -137,6 +171,15 @@ impl PlainYearMonth {
         self.calendar.identifier()
     }
 
+    /// Creates a `PlainYearMonth` using the fields provided from a [`PartialDate`]
+    pub fn with(
+        &self,
+        _partial: PartialDate,
+        _overflow: ArithmeticOverflow,
+    ) -> TemporalResult<Self> {
+        Err(TemporalError::general("Not yet implemented."))
+    }
+
     /// Compares one `PlainYearMonth` to another `PlainYearMonth` using their
     /// `IsoDate` representation.
     ///
@@ -151,39 +194,40 @@ impl PlainYearMonth {
         self.iso.cmp(&other.iso)
     }
 
-    pub fn add_duration(
-        &self,
-        duration: &Duration,
-        overflow: ArithmeticOverflow,
-    ) -> TemporalResult<Self> {
+    /// Adds a [`Duration`] from the current `PlainYearMonth`.
+    #[inline]
+    pub fn add(&self, duration: &Duration, overflow: ArithmeticOverflow) -> TemporalResult<Self> {
         self.add_or_subtract_duration(duration, overflow)
     }
 
-    pub fn subtract_duration(
+    /// Subtracts a [`Duration`] from the current `PlainYearMonth`.
+    #[inline]
+    pub fn subtract(
         &self,
         duration: &Duration,
         overflow: ArithmeticOverflow,
     ) -> TemporalResult<Self> {
         self.add_or_subtract_duration(&duration.negated(), overflow)
     }
 
-    pub(crate) fn add_or_subtract_duration(
-        &self,
-        duration: &Duration,
-        overflow: ArithmeticOverflow,
-    ) -> TemporalResult<Self> {
-        let partial = PartialDate::try_from_year_month(self)?;
-
-        let mut intermediate_date = self.calendar().date_from_partial(&partial, overflow)?;
-
-        intermediate_date = intermediate_date.add_date(duration, Some(overflow))?;
+    /// Returns a `Duration` representing the period of time from this `PlainYearMonth` until the other `PlainYearMonth`.
+    #[inline]
+    pub fn until(&self, other: &Self, settings: DifferenceSettings) -> TemporalResult<Duration> {
+        self.diff(DifferenceOperation::Until, other, settings)
+    }
 
-        let result_fields = PartialDate::default().with_fallback_date(&intermediate_date)?;
+    /// Returns a `Duration` representing the period of time from this `PlainYearMonth` since the other `PlainYearMonth`.
+    #[inline]
+    pub fn since(&self, other: &Self, settings: DifferenceSettings) -> TemporalResult<Duration> {
+        self.diff(DifferenceOperation::Since, other, settings)
+    }
 
-        self.calendar()
-            .year_month_from_partial(&result_fields, overflow)
+    pub fn to_plain_date(&self) -> TemporalResult<PlainDate> {
+        Err(TemporalError::general("Not yet iimplemented."))
     }
 
+    /// Returns a RFC9557 IXDTF string for the current `PlainYearMonth`
+    #[inline]
     pub fn to_ixdtf_string(&self, display_calendar: DisplayCalendar) -> String {
         let ixdtf = FormattableYearMonth {
             date: FormattableDate(self.iso_year(), self.iso_month(), self.iso.day),

src/builtins/core/zoneddatetime.rs

@@ -408,6 +408,10 @@ impl ZonedDateTime {
         self.instant
     }
 
+    pub fn with(&self, _partial: PartialZonedDateTime) -> TemporalResult<Self> {
+        Err(TemporalError::general("Not yet implemented"))
+    }
+
     /// Creates a new `ZonedDateTime` from the current `ZonedDateTime`
     /// combined with the provided `TimeZone`.
     pub fn with_timezone(&self, timezone: TimeZone) -> TemporalResult<Self> {
@@ -438,6 +442,15 @@ impl ZonedDateTime {
 // ==== HoursInDay accessor method implementation ====
 
 impl ZonedDateTime {
+    // TODO: Add direction parameter to either zoneddatetime.rs or option.rs
+    pub fn get_time_zone_transition_with_provider(
+        &self,
+        _direction: bool,
+        _provider: &impl TimeZoneProvider,
+    ) -> TemporalResult<Self> {
+        Err(TemporalError::general("Not yet implemented"))
+    }
+
     pub fn hours_in_day_with_provider(
         &self,
         provider: &impl TimeZoneProvider,

temporal_capi/src/duration.rs

@@ -228,6 +228,7 @@ pub mod ffi {
         }
 
         // TODO round_with_provider (needs time zone stuff)
+        // TODO total_with_provider (needs time zone stuff)
     }
 }
 

temporal_capi/src/plain_date_time.rs

@@ -251,6 +251,13 @@ pub mod ffi {
                 .map_err(Into::into)
         }
 
+        pub fn to_plain_time(&self) -> Result<Box<PlainTime>, TemporalError> {
+            self.0
+                .to_plain_time()
+                .map(|x| Box::new(PlainTime(x)))
+                .map_err(Into::into)
+        }
+
         pub fn to_ixdtf_string(
             &self,
             options: ToStringRoundingOptions,