slight changes to with() function and covert fallback macro to regular function

Author: lockels

src/builtins/core/date.rs

@@ -81,62 +81,50 @@ impl PartialDate {
     crate::impl_with_fallback_method!(with_fallback_year_month, () PlainYearMonth); // excludes day
     crate::impl_with_fallback_method!(with_fallback_date, (with_day: day) PlainDate);
     crate::impl_with_fallback_method!(with_fallback_datetime, (with_day:day) PlainDateTime);
-    crate::impl_with_fallback_method_zoned!(with_fallback_zoneddatetime, (with_day:day), ZonedDateTime);
-}
 
-#[doc(hidden)]
-#[macro_export]
-macro_rules! impl_with_fallback_method_zoned {
-    ($method_name:ident, (with_day: $day:ident), $component_type:ty) => {
-        pub(crate) fn $method_name(
-            &self,
-            fallback: &$component_type,
-            provider: &impl TimeZoneProvider,
-        ) -> TemporalResult<Self> {
-            let era = if let Some(era) = self.era {
-                Some(era)
-            } else {
-                let era = fallback.era_with_provider(provider)?;
-                era.map(|e| {
-                    TinyAsciiStr::<19>::try_from_utf8(e.as_bytes())
-                        .map_err(|e| TemporalError::general(format!("{e}")))
-                })
-                .transpose()?
-            };
-
-            let fallback_era_year = fallback.era_year_with_provider(provider)?;
-            let era_year = self
-                .era_year
-                .map_or_else(|| fallback_era_year, |ey| Some(ey));
+    pub(crate) fn with_fallback_zoneddatetime(
+        &self,
+        fallback: &ZonedDateTime,
+        provider: &impl TimeZoneProvider,
+    ) -> TemporalResult<Self> {
+        let era = if let Some(era) = self.era {
+            Some(era)
+        } else {
+            let era = fallback.era_with_provider(provider)?;
+            era.map(|e| {
+                TinyAsciiStr::<19>::try_from_utf8(e.as_bytes())
+                    .map_err(|e| TemporalError::general(format!("{e}")))
+            })
+            .transpose()?
+        };
 
-            let (month, month_code) = match (self.month, self.month_code) {
-                (Some(month), Some(mc)) => (Some(month), Some(mc)),
-                (Some(month), None) => (Some(month), Some(month_to_month_code(month)?)),
-                (None, Some(mc)) => (Some(mc.to_month_integer()).map(Into::into), Some(mc)),
-                (None, None) => (
-                    Some(fallback.month_with_provider(provider)?).map(Into::into),
-                    Some(fallback.month_code_with_provider(provider)?),
-                ),
-            };
+        let fallback_era_year = fallback.era_year_with_provider(provider)?;
+        let era_year = self.era_year.map_or_else(|| fallback_era_year, Some);
+
+        let (month, month_code) = match (self.month, self.month_code) {
+            (Some(month), Some(mc)) => (Some(month), Some(mc)),
+            (Some(month), None) => (Some(month), Some(month_to_month_code(month)?)),
+            (None, Some(mc)) => (Some(mc.to_month_integer()), Some(mc)),
+            (None, None) => (
+                Some(fallback.month_with_provider(provider)?),
+                Some(fallback.month_code_with_provider(provider)?),
+            ),
+        };
 
-            #[allow(clippy::needless_update)]
-            {
-                Ok(Self {
-                    year: Some(self.year.unwrap_or(fallback.year_with_provider(provider)?)),
-                    month,
-                    month_code,
-                    $day: Some(
-                        self.day
-                            .unwrap_or(fallback.day_with_provider(provider)?.into()),
-                    ),
-                    era,
-                    era_year,
-                    calendar: fallback.calendar().clone(),
-                    ..Default::default()
-                })
-            }
+        #[allow(clippy::needless_update)]
+        {
+            Ok(Self {
+                year: Some(self.year.unwrap_or(fallback.year_with_provider(provider)?)),
+                month,
+                month_code,
+                day: Some(self.day.unwrap_or(fallback.day_with_provider(provider)?)),
+                era,
+                era_year,
+                calendar: fallback.calendar().clone(),
+                ..Default::default()
+            })
         }
-    };
+    }
 }
 
 // Use macro to impl fallback methods to avoid having a trait method.

src/builtins/core/zoneddatetime.rs

@@ -517,22 +517,23 @@ impl ZonedDateTime {
     pub fn with(
         &self,
         partial: PartialZonedDateTime,
-        disambiguation: Disambiguation,
-        offset_option: OffsetDisambiguation,
+        disambiguation: Option<Disambiguation>,
+        offset_option: Option<OffsetDisambiguation>,
         overflow: Option<ArithmeticOverflow>,
         provider: &impl TimeZoneProvider,
     ) -> TemporalResult<Self> {
+        let overflow = overflow.unwrap_or_default();
+        let disambiguation = disambiguation.unwrap_or_default();
+        let offset_option = offset_option.unwrap_or(OffsetDisambiguation::Reject);
+
         // 23. Let dateTimeResult be ? InterpretTemporalDateTimeFields(calendar, fields, overflow).
         let result_date = self.calendar.date_from_partial(
             &partial.date.with_fallback_zoneddatetime(self, provider)?,
-            overflow.unwrap_or(ArithmeticOverflow::Constrain),
+            ArithmeticOverflow::Constrain,
         )?;
 
         let original_iso = self.tz.get_iso_datetime_for(&self.instant, provider)?.time;
-        let time = original_iso.with(
-            partial.time,
-            overflow.unwrap_or(ArithmeticOverflow::Constrain),
-        )?;
+        let time = original_iso.with(partial.time, overflow)?;
 
         // 24. Let newOffsetNanoseconds be ! ParseDateTimeUTCOffset(fields.[[OffsetString]]).
         let original_offset = self.offset_nanoseconds_with_provider(provider)?;