LibJS: Implement Temporal.Duration.prototype.with()

Userland/Libraries/LibJS/Runtime/CommonPropertyNames.h

@@ -362,6 +362,7 @@ namespace JS {
  P(values) \
  P(warn) \
  P(weeks) \
+ P(with) \
  P(writable) \
  P(years)
 

Userland/Libraries/LibJS/Runtime/ErrorTypes.h

@@ -168,6 +168,7 @@
  M(StringRepeatCountMustBe, "repeat count must be a {} number") \
  M(TemporalInvalidCalendarIdentifier, "Invalid calendar identifier '{}'") \
  M(TemporalInvalidDuration, "Invalid duration") \
+ M(TemporalInvalidDurationLikeObject, "Invalid duration-like object") \
  M(TemporalInvalidEpochNanoseconds, "Invalid epoch nanoseconds value, must be in range -86400 * 10^17 to 86400 * 10^17") \
  M(TemporalInvalidISODate, "Invalid ISO date") \
  M(TemporalInvalidTime, "Invalid time") \

Userland/Libraries/LibJS/Runtime/Temporal/Duration.cpp

@@ -70,6 +70,75 @@ bool is_valid_duration(double years, double months, double weeks, double days, d
  return true;
 }
 
+// 7.5.6 ToPartialDuration ( temporalDurationLike ), https://tc39.es/proposal-temporal/#sec-temporal-topartialduration
+PartialDuration to_partial_duration(GlobalObject& global_object, Value temporal_duration_like)
+{
+ auto& vm = global_object.vm();
+
+ // 1. If Type(temporalDurationLike) is not Object, then
+ if (!temporal_duration_like.is_object()) {
+ vm.throw_exception<TypeError>(global_object, ErrorType::NotAnObject, temporal_duration_like.to_string_without_side_effects());
+ return {};
+ }
+
+ // 2. Let result be the new Record { [[Years]]: undefined, [[Months]]: undefined, [[Weeks]]: undefined, [[Days]]: undefined, [[Hours]]: undefined, [[Minutes]]: undefined, [[Seconds]]: undefined, [[Milliseconds]]: undefined, [[Microseconds]]: undefined, [[Nanoseconds]]: undefined }.
+ auto result = PartialDuration {};
+
+ // 3. Let any be false.
+ auto any = false;
+
+ struct PartialDurationProperty {
+ Optional<double> PartialDuration::*internal_slot { nullptr };
+ PropertyName property;
+ };
+ auto properties = AK::Array<PartialDurationProperty, 10> {
+ PartialDurationProperty { &PartialDuration::years, vm.names.years },
+ PartialDurationProperty { &PartialDuration::months, vm.names.months },
+ PartialDurationProperty { &PartialDuration::weeks, vm.names.weeks },
+ PartialDurationProperty { &PartialDuration::days, vm.names.days },
+ PartialDurationProperty { &PartialDuration::hours, vm.names.hours },
+ PartialDurationProperty { &PartialDuration::minutes, vm.names.minutes },
+ PartialDurationProperty { &PartialDuration::seconds, vm.names.seconds },
+ PartialDurationProperty { &PartialDuration::milliseconds, vm.names.milliseconds },
+ PartialDurationProperty { &PartialDuration::microseconds, vm.names.microseconds },
+ PartialDurationProperty { &PartialDuration::nanoseconds, vm.names.nanoseconds },
+ };
+
+ // 4. For each row of Table 7, except the header row, in table order, do
+ for (auto& [internal_slot, property] : properties) {
+ // a. Let property be the Property value of the current row.
+
+ // b. Let value be ? Get(temporalDurationLike, property).
+ auto value = temporal_duration_like.as_object().get(property);
+ if (vm.exception())
+ return {};
+
+ // c. If value is not undefined, then
+ if (!value.is_undefined()) {
+ // i. Set any to true.
+ any = true;
+
+ // ii. Set value to ? ToIntegerOrInfinity(value).
+ auto value_number = value.to_integer_or_infinity(global_object);
+ if (vm.exception())
+ return {};
+
+ // iii. Set result's internal slot whose name is the Internal Slot value of the current row to value.
+ result.*internal_slot = value_number;
+ }
+ }
+
+ // 5. If any is false, then
+ if (!any) {
+ // a. Throw a TypeError exception.
+ vm.throw_exception<TypeError>(global_object, ErrorType::TemporalInvalidDurationLikeObject);
+ return {};
+ }
+
+ // 6. Return result.
+ return result;
+}
+
 // 7.5.7 CreateTemporalDuration ( years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds [ , newTarget ] ), https://tc39.es/proposal-temporal/#sec-temporal-createtemporalduration
 Duration* create_temporal_duration(GlobalObject& global_object, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, FunctionObject* new_target)
 {

Userland/Libraries/LibJS/Runtime/Temporal/Duration.h

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <AK/Optional.h>
 #include <LibJS/Runtime/Object.h>
 
 namespace JS::Temporal {
@@ -43,8 +44,22 @@ class Duration final : public Object {
  double m_nanoseconds; // [[Nanoseconds]]
 };
 
+struct PartialDuration {
+ Optional<double> years;
+ Optional<double> months;
+ Optional<double> weeks;
+ Optional<double> days;
+ Optional<double> hours;
+ Optional<double> minutes;
+ Optional<double> seconds;
+ Optional<double> milliseconds;
+ Optional<double> microseconds;
+ Optional<double> nanoseconds;
+};
+
 i8 duration_sign(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds);
 bool is_valid_duration(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds);
+PartialDuration to_partial_duration(GlobalObject&, Value temporal_duration_like);
 Duration* create_temporal_duration(GlobalObject&, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, FunctionObject* new_target = nullptr);
 
 }

Userland/Libraries/LibJS/Runtime/Temporal/DurationPrototype.cpp

@@ -39,6 +39,7 @@ void DurationPrototype::initialize(GlobalObject& global_object)
  define_native_accessor(vm.names.blank, blank_getter, {}, Attribute::Configurable);
 
  u8 attr = Attribute::Writable | Attribute::Configurable;
+ define_native_function(vm.names.with, with, 1, attr);
  define_native_function(vm.names.valueOf, value_of, 0, attr);
 }
 
@@ -218,6 +219,84 @@ JS_DEFINE_NATIVE_FUNCTION(DurationPrototype::blank_getter)
  return Value(false);
 }
 
+// 7.3.15 Temporal.Duration.prototype.with ( temporalDurationLike ), https://tc39.es/proposal-temporal/#sec-temporal.duration.prototype.with
+JS_DEFINE_NATIVE_FUNCTION(DurationPrototype::with)
+{
+ // 1. Let duration be the this value.
+ // 2. Perform ? RequireInternalSlot(duration, [[InitializedTemporalDuration]]).
+ auto* duration = typed_this(global_object);
+ if (vm.exception())
+ return {};
+
+ // 3. Let temporalDurationLike be ? ToPartialDuration(temporalDurationLike).
+ auto temporal_duration_like = to_partial_duration(global_object, vm.argument(0));
+ if (vm.exception())
+ return {};
+
+ // 4. If temporalDurationLike.[[Years]] is not undefined, then
+ // a. Let years be temporalDurationLike.[[Years]].
+ // 5. Else,
+ // a. Let years be duration.[[Years]].
+ auto years = temporal_duration_like.years.value_or(duration->years());
+
+ // 6. If temporalDurationLike.[[Months]] is not undefined, then
+ // a. Let months be temporalDurationLike.[[Months]].
+ // 7. Else,
+ // a. Let months be duration.[[Months]].
+ auto months = temporal_duration_like.months.value_or(duration->months());
+
+ // 8. If temporalDurationLike.[[Weeks]] is not undefined, then
+ // a. Let weeks be temporalDurationLike.[[Weeks]].
+ // 9. Else,
+ // a. Let weeks be duration.[[Weeks]].
+ auto weeks = temporal_duration_like.weeks.value_or(duration->weeks());
+
+ // 10. If temporalDurationLike.[[Days]] is not undefined, then
+ // a. Let days be temporalDurationLike.[[Days]].
+ // 11. Else,
+ // a. Let days be duration.[[Days]].
+ auto days = temporal_duration_like.days.value_or(duration->days());
+
+ // 12. If temporalDurationLike.[[Hours]] is not undefined, then
+ // a. Let hours be temporalDurationLike.[[Hours]].
+ // 13. Else,
+ // a. Let hours be duration.[[Hours]].
+ auto hours = temporal_duration_like.hours.value_or(duration->hours());
+
+ // 14. If temporalDurationLike.[[Minutes]] is not undefined, then
+ // a. Let minutes be temporalDurationLike.[[Minutes]].
+ // 15. Else,
+ // a. Let minutes be duration.[[Minutes]].
+ auto minutes = temporal_duration_like.minutes.value_or(duration->minutes());
+
+ // 16. If temporalDurationLike.[[Seconds]] is not undefined, then
+ // a. Let seconds be temporalDurationLike.[[Seconds]].
+ // 17. Else,
+ // a. Let seconds be duration.[[Seconds]].
+ auto seconds = temporal_duration_like.seconds.value_or(duration->seconds());
+
+ // 18. If temporalDurationLike.[[Milliseconds]] is not undefined, then
+ // a. Let milliseconds be temporalDurationLike.[[Milliseconds]].
+ // 19. Else,
+ // a. Let milliseconds be duration.[[Milliseconds]].
+ auto milliseconds = temporal_duration_like.milliseconds.value_or(duration->milliseconds());
+
+ // 20. If temporalDurationLike.[[Microseconds]] is not undefined, then
+ // a. Let microseconds be temporalDurationLike.[[Microseconds]].
+ // 21. Else,
+ // a. Let microseconds be duration.[[Microseconds]].
+ auto microseconds = temporal_duration_like.microseconds.value_or(duration->microseconds());
+
+ // 22. If temporalDurationLike.[[Nanoseconds]] is not undefined, then
+ // a. Let nanoseconds be temporalDurationLike.[[Nanoseconds]].
+ // 23. Else,
+ // a. Let nanoseconds be duration.[[Nanoseconds]].
+ auto nanoseconds = temporal_duration_like.nanoseconds.value_or(duration->nanoseconds());
+
+ // 24. Return ? CreateTemporalDuration(years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds).
+ return create_temporal_duration(global_object, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds);
+}
+
 // 7.3.25 Temporal.Duration.prototype.valueOf ( ), https://tc39.es/proposal-temporal/#sec-temporal.duration.prototype.valueof
 JS_DEFINE_NATIVE_FUNCTION(DurationPrototype::value_of)
 {

Userland/Libraries/LibJS/Runtime/Temporal/DurationPrototype.h

@@ -31,6 +31,7 @@ class DurationPrototype final : public Object {
  JS_DECLARE_NATIVE_FUNCTION(nanoseconds_getter);
  JS_DECLARE_NATIVE_FUNCTION(sign_getter);
  JS_DECLARE_NATIVE_FUNCTION(blank_getter);
+ JS_DECLARE_NATIVE_FUNCTION(with);
  JS_DECLARE_NATIVE_FUNCTION(value_of);
 };
 

Userland/Libraries/LibJS/Tests/builtins/Temporal/Duration/Duration.prototype.with.js

@@ -0,0 +1,87 @@
+const DURATION_PROPERTIES = [
+ "years",
+ "months",
+ "weeks",
+ "days",
+ "hours",
+ "minutes",
+ "seconds",
+ "milliseconds",
+ "microseconds",
+ "nanoseconds",
+];
+
+describe("correct behavior", () => {
+ test("length is 1", () => {
+ expect(Temporal.Duration.prototype.with).toHaveLength(1);
+ });
+
+ test("basic functionality", () => {
+ const duration = new Temporal.Duration(1, 2, 3).with({ years: 4, foo: 5, weeks: 6 });
+ expect(duration.years).toBe(4);
+ expect(duration.months).toBe(2);
+ expect(duration.weeks).toBe(6);
+ });
+
+ test("each property is looked up from the object", () => {
+ for (const property of DURATION_PROPERTIES) {
+ const duration = new Temporal.Duration().with({ [property]: 1 });
+ expect(duration[property]).toBe(1);
+ }
+ });
+
+ test("each property is coerced to number", () => {
+ for (const property of DURATION_PROPERTIES) {
+ const duration = new Temporal.Duration().with({ [property]: "1" });
+ expect(duration[property]).toBe(1);
+ }
+ });
+});
+
+test("errors", () => {
+ test("this value must be a Temporal.Duration object", () => {
+ expect(() => {
+ Temporal.Duration.prototype.with.call("foo");
+ }).toThrowWithMessage(TypeError, "Not a Temporal.Duration");
+ });
+
+ test("argument is not an object", () => {
+ expect(() => {
+ new Temporal.Duration().with("foo");
+ }).toThrowWithMessage(TypeError, "foo is not an object");
+ expect(() => {
+ new Temporal.Duration().with(42);
+ }).toThrowWithMessage(TypeError, "42 is not an object");
+ });
+
+ test("argument is an invalid duration-like object", () => {
+ expect(() => {
+ new Temporal.Duration().with({});
+ }).toThrowWithMessage(TypeError, "Invalid duration-like object");
+ expect(() => {
+ new Temporal.Duration().with({ foo: 1, bar: 2 });
+ }).toThrowWithMessage(TypeError, "Invalid duration-like object");
+ });
+
+ test("error when coercing property to number", () => {
+ for (const property of DURATION_PROPERTIES) {
+ expect(() => {
+ new Temporal.Duration().with({
+ [property]: {
+ valueOf() {
+ throw new Error();
+ },
+ },
+ });
+ }).toThrow(Error);
+ }
+ });
+
+ test("invalid duration value", () => {
+ for (const property of DURATION_PROPERTIES) {
+ expect(() => {
+ new Temporal.Duration().with({ [property]: Infinity });
+ }).toThrowWithMessage(RangeError, "Invalid duration");
+ }
+ });
+});