Merge branch 'main' into add-offset-struct

Author: nekevss

src/builtins/compiled/zoneddatetime.rs

@@ -5,7 +5,7 @@ use crate::{
         ArithmeticOverflow, DifferenceSettings, Disambiguation, DisplayCalendar, DisplayOffset,
         DisplayTimeZone, OffsetDisambiguation, ToStringRoundingOptions,
     },
-    Duration, PlainDate, PlainDateTime, PlainTime, TemporalError, TemporalResult,
+    Duration, MonthCode, PlainDate, PlainDateTime, PlainTime, TemporalError, TemporalResult,
 };
 use alloc::string::String;
 use tinystr::TinyAsciiStr;
@@ -58,7 +58,7 @@ impl ZonedDateTime {
     /// Returns the `ZonedDateTime`'s calendar month code.
     ///
     /// Enable with the `compiled_data` feature flag.
-    pub fn month_code(&self) -> TemporalResult<TinyAsciiStr<4>> {
+    pub fn month_code(&self) -> TemporalResult<MonthCode> {
         let provider = TZ_PROVIDER
             .lock()
             .map_err(|_| TemporalError::general("Unable to acquire lock"))?;

src/builtins/core/calendar.rs

@@ -3,13 +3,6 @@
 //! The goal of the calendar module of `boa_temporal` is to provide
 //! Temporal compatible calendar implementations.
 
-// TODO: It may finally be time to clean up API to use `IsoDate` and `DateDuration` directly.
-
-use alloc::string::String;
-use alloc::vec::Vec;
-use core::str::FromStr;
-use icu_calendar::types::{Era as IcuEra, MonthCode as IcuMonthCode, MonthInfo, YearInfo};
-
 use crate::{
     builtins::core::{
         duration::{DateDuration, TimeDuration},
@@ -20,7 +13,9 @@ use crate::{
     parsers::parse_allowed_calendar_formats,
     TemporalError, TemporalResult,
 };
+use core::str::FromStr;
 
+use icu_calendar::types::{Era as IcuEra, MonthCode as IcuMonthCode, MonthInfo, YearInfo};
 use icu_calendar::{
     any_calendar::AnyDateInner,
     cal::{
@@ -40,8 +35,8 @@ use super::{PartialDate, ZonedDateTime};
 mod era;
 mod types;
 
-pub use types::ResolvedCalendarFields;
-pub(crate) use types::{ascii_four_to_integer, month_to_month_code};
+pub(crate) use types::{month_to_month_code, ResolutionType};
+pub use types::{MonthCode, ResolvedCalendarFields};
 
 use era::EraInfo;
 
@@ -226,13 +221,14 @@ impl Calendar {
         partial: &PartialDate,
         overflow: ArithmeticOverflow,
     ) -> TemporalResult<PlainDate> {
-        let resolved_fields = ResolvedCalendarFields::try_from_partial(partial, overflow)?;
+        let resolved_fields =
+            ResolvedCalendarFields::try_from_partial(partial, overflow, ResolutionType::Date)?;
 
         if self.is_iso() {
             // Resolve month and monthCode;
             return PlainDate::new_with_overflow(
                 resolved_fields.era_year.year,
-                resolved_fields.month_code.as_iso_month_integer()?,
+                resolved_fields.month_code.to_month_integer(),
                 resolved_fields.day,
                 self.clone(),
                 overflow,
@@ -264,10 +260,11 @@ impl Calendar {
         partial: &PartialDate,
         overflow: ArithmeticOverflow,
     ) -> TemporalResult<PlainMonthDay> {
-        let resolved_fields = ResolvedCalendarFields::try_from_partial(partial, overflow)?;
+        let resolved_fields =
+            ResolvedCalendarFields::try_from_partial(partial, overflow, ResolutionType::MonthDay)?;
         if self.is_iso() {
             return PlainMonthDay::new_with_overflow(
-                resolved_fields.month_code.as_iso_month_integer()?,
+                resolved_fields.month_code.to_month_integer(),
                 resolved_fields.day,
                 self.clone(),
                 overflow,
@@ -286,11 +283,12 @@ impl Calendar {
         partial: &PartialDate,
         overflow: ArithmeticOverflow,
     ) -> TemporalResult<PlainYearMonth> {
-        let resolved_fields = ResolvedCalendarFields::try_from_partial(partial, overflow)?;
+        let resolved_fields =
+            ResolvedCalendarFields::try_from_partial(partial, overflow, ResolutionType::YearMonth)?;
         if self.is_iso() {
             return PlainYearMonth::new_with_overflow(
                 resolved_fields.era_year.year,
-                resolved_fields.month_code.as_iso_month_integer()?,
+                resolved_fields.month_code.to_month_integer(),
                 Some(resolved_fields.day),
                 self.clone(),
                 overflow,
@@ -360,7 +358,6 @@ impl Calendar {
             let date_duration = one.diff_iso_date(two, largest_unit)?;
             return Ok(Duration::from(date_duration));
         }
-
         Err(TemporalError::range().with_message("Not yet implemented."))
     }
 
@@ -396,56 +393,57 @@ impl Calendar {
         if self.is_iso() {
             return Ok(iso_date.month);
         }
-
-        Err(TemporalError::range().with_message("Not yet implemented."))
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        Ok(self.0.month(&calendar_date).month_number())
     }
 
     /// `CalendarMonthCode`
-    pub fn month_code(&self, iso_date: &IsoDate) -> TemporalResult<TinyAsciiStr<4>> {
+    pub fn month_code(&self, iso_date: &IsoDate) -> TemporalResult<MonthCode> {
         if self.is_iso() {
-            return Ok(iso_date.as_icu4x()?.month().standard_code.0);
+            let mc = iso_date.as_icu4x()?.month().standard_code.0;
+            return Ok(MonthCode(mc));
         }
-
-        Err(TemporalError::range().with_message("Not yet implemented."))
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        Ok(MonthCode(self.0.month(&calendar_date).standard_code.0))
     }
 
     /// `CalendarDay`
     pub fn day(&self, iso_date: &IsoDate) -> TemporalResult<u8> {
         if self.is_iso() {
             return Ok(iso_date.day);
         }
-
-        Err(TemporalError::range().with_message("Not yet implemented."))
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        Ok(self.0.day_of_month(&calendar_date).0)
     }
 
     /// `CalendarDayOfWeek`
     pub fn day_of_week(&self, iso_date: &IsoDate) -> TemporalResult<u16> {
         if self.is_iso() {
             return Ok(iso_date.as_icu4x()?.day_of_week() as u16);
         }
-
-        Err(TemporalError::range().with_message("Not yet implemented."))
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        // TODO: Understand ICU4X's decision for `IsoWeekDay` to be `i8`
+        Ok(self.0.day_of_week(&calendar_date) as u16)
     }
 
     /// `CalendarDayOfYear`
     pub fn day_of_year(&self, iso_date: &IsoDate) -> TemporalResult<u16> {
         if self.is_iso() {
             return Ok(iso_date.as_icu4x()?.day_of_year_info().day_of_year);
         }
-        Err(TemporalError::range().with_message("Not yet implemented."))?
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        Ok(self.0.day_of_year_info(&calendar_date).day_of_year)
     }
 
     /// `CalendarWeekOfYear`
     pub fn week_of_year(&self, iso_date: &IsoDate) -> TemporalResult<Option<u16>> {
         if self.is_iso() {
             let date = iso_date.as_icu4x()?;
-
             let week_calculator = WeekCalculator::default();
-
             let week_of = date.week_of_year(&week_calculator);
-
             return Ok(Some(week_of.week as u16));
         }
+        // TODO: Research in ICU4X and determine best approach.
         Err(TemporalError::range().with_message("Not yet implemented."))
     }
 
@@ -464,6 +462,7 @@ impl Calendar {
                 RelativeUnit::Next => Ok(Some(date.year().extended_year + 1)),
             };
         }
+        // TODO: Research in ICU4X and determine best approach.
         Err(TemporalError::range().with_message("Not yet implemented."))
     }
 
@@ -472,6 +471,7 @@ impl Calendar {
         if self.is_iso() {
             return Ok(7);
         }
+        // TODO: Research in ICU4X and determine best approach.
         Err(TemporalError::range().with_message("Not yet implemented."))
     }
 
@@ -480,40 +480,35 @@ impl Calendar {
         if self.is_iso() {
             return Ok(iso_date.as_icu4x()?.days_in_month() as u16);
         }
-        Err(TemporalError::range().with_message("Not yet implemented."))
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        Ok(self.0.days_in_month(&calendar_date) as u16)
     }
 
     /// `CalendarDaysInYear`
     pub fn days_in_year(&self, iso_date: &IsoDate) -> TemporalResult<u16> {
         if self.is_iso() {
             return Ok(iso_date.as_icu4x()?.days_in_year());
         }
-
-        Err(TemporalError::range().with_message("Not yet implemented."))
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        Ok(self.0.days_in_year(&calendar_date))
     }
 
     /// `CalendarMonthsInYear`
-    pub fn months_in_year(&self, _iso_date: &IsoDate) -> TemporalResult<u16> {
+    pub fn months_in_year(&self, iso_date: &IsoDate) -> TemporalResult<u16> {
         if self.is_iso() {
             return Ok(12);
         }
-        Err(TemporalError::range().with_message("Not yet implemented."))
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        Ok(self.0.months_in_year(&calendar_date) as u16)
     }
 
     /// `CalendarInLeapYear`
     pub fn in_leap_year(&self, iso_date: &IsoDate) -> TemporalResult<bool> {
         if self.is_iso() {
             return Ok(iso_date.as_icu4x()?.is_in_leap_year());
         }
-        Err(TemporalError::range().with_message("Not yet implemented."))
-    }
-
-    /// `CalendarFields`
-    pub fn fields(&self, fields: Vec<String>) -> TemporalResult<Vec<String>> {
-        if self.is_iso() {
-            return Ok(fields);
-        }
-        Err(TemporalError::range().with_message("Not yet implemented."))
+        let calendar_date = self.0.date_from_iso(iso_date.as_icu4x()?);
+        Ok(self.0.is_in_leap_year(&calendar_date))
     }
 
     /// Returns the identifier of this calendar slot.