Implement ``with`` for ``ZonedDateTime``

[lockels]

This method is currently unimplemented here

spec for this method

[lockels]

I've noticed this method is not yet implemented, and would like to work on it

[nekevss]

Oops! Nice catch!

Go ahead :)

[lockels]

I've been struggling a lot with getting the tests to pass for this issue, i found this one very similar looking method in ZonedDateTime::from_partial_with_provider. This seems to implement the spec for ZonedDateTime::with. I'm wondering if there's something you might now about this, and why not all the tests when using this function as the implementation for ZonedDateTime::with

pub fn from_partial_with_provider(
        partial: PartialZonedDateTime,
        overflow: Option<ArithmeticOverflow>,
        disambiguation: Option<Disambiguation>,
        offset_option: Option<OffsetDisambiguation>,
        provider: &impl TimeZoneProvider,
    ) -> TemporalResult<Self> {
        let overflow = overflow.unwrap_or(ArithmeticOverflow::Constrain);
        let disambiguation = disambiguation.unwrap_or(Disambiguation::Compatible);
        let offset_option = offset_option.unwrap_or(OffsetDisambiguation::Reject);

        let date = partial
            .date
            .calendar
            .date_from_partial(&partial.date, overflow)?
            .iso;
        let time = if !partial.time.is_empty() {
            Some(IsoTime::default().with(partial.time, overflow)?)
        } else {
            None
        };

        // Handle time zones
        let offset_nanos = partial
            .offset
            .map(|offset| i64::from(offset.0) * 60_000_000_000);

        let timezone = partial.timezone.unwrap_or_default();

        let epoch_nanos = interpret_isodatetime_offset(
            date,
            time,
            false,
            offset_nanos,
            &timezone,
            disambiguation,
            offset_option,
            true,
            provider,
        )?;

        Ok(Self::new_unchecked(
            Instant::from(epoch_nanos),
            partial.date.calendar.clone(),
            timezone,
        ))
    }

[nekevss]

This looks like it's the from implementation. These are very similar and this method could probably be used as reference for steps 19+.

There are two key differences between the from and with implementations. The first is that one is a static_property (in rust, ZonedDateTime::from(args)) while the other is a method on the builtin (in rust, ZonedDateTime::with(&self, args)). The second key is also primarily the reason for the first, self is used to fill in any missing gap of the partial. You can see this in the implementations on the other builtins.

Steps 17-18 are pretty loaded functionality wise in the specification. The difficult part is going to be interpreting that functionality.

17. Let partialZonedDateTime be ? PrepareCalendarFields(calendar, temporalZonedDateTimeLike, « year, month, month-code, day », « hour, minute, second, millisecond, microsecond, nanosecond, offset », partial).
18. Set fields to CalendarMergeFields(calendar, fields, partialZonedDateTime).

For other builtins, this was done here. ZoneDateTime should probably be added to that (although, it may not be able to use the macro due to the provider methods). And then manual unwraps may need to be added for handling the offset.

I'd also recommend looking at PlainDateTime::with for more context on the with implementation for time fields.

This one's a little harder mostly due to the abstract nature of the adapting PrepareCalendarFields. Feel free to comment here or send a message on Matrix. 😄