Format Temporal values in console.log, util.inspect, and test pretty-format

src/js/internal/util/inspect.js

@@ -182,6 +182,12 @@ const {
   isTypedArray,
 } = require("node:util/types");
 
+// getTemporalLabel(value) is e.g. "Temporal.PlainDate", or undefined for
+// non-Temporal values; getTemporalDisplayString is the value's default-options
+// toString() text, computed without calling user-observable methods.
+const getTemporalLabel = $newCppFunction("Temporal.cpp", "jsFunctionTemporalLabel", 1);
+const getTemporalDisplayString = $newCppFunction("Temporal.cpp", "jsFunctionTemporalToDisplayString", 1);
+
 // We need this duplicate here to avoid a circular dependency between node:assert and node:util.
 class AssertionError extends Error {
   constructor(message, isForced = false) {
@@ -1482,6 +1488,7 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
   let braces;
   let extraKeys;
   let noIterator = true;
+  let temporalLabel;
   let i = 0;
   const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
 
@@ -1631,6 +1638,16 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
       if (keys.length === 0 && protoProps === undefined) {
         return base;
       }
+    } else if ((temporalLabel = getTemporalLabel(value)) !== undefined) {
+      // JSC names the constructors `PlainDate` where V8 uses `Temporal.PlainDate`;
+      // map direct instances onto the label so the prefix matches Node's output.
+      const effectiveConstructor =
+        constructor !== null && `Temporal.${constructor}` === temporalLabel ? temporalLabel : constructor;
+      const prefix = getPrefix(effectiveConstructor, tag, temporalLabel);
+      base = `${prefix}${getTemporalDisplayString(value)}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, "date");
+      }
     } else {
       if (keys.length === 0 && protoProps === undefined) {
         if (isExternal(value)) {

src/jsc/ConsoleObject.rs

@@ -1925,6 +1925,7 @@
 
         JSON,
         ToJSON,
+        Temporal,
         NativeCode,
 
         JSX,
@@ -1996,6 +1997,7 @@
         Promise,
         JSON,
         ToJSON,
+        Temporal,
         NativeCode,
         JSX,
         Event,
@@ -2042,6 +2044,7 @@
                 TagPayload::Promise => Tag::Promise,
                 TagPayload::JSON => Tag::JSON,
                 TagPayload::ToJSON => Tag::ToJSON,
+                TagPayload::Temporal => Tag::Temporal,
                 TagPayload::NativeCode => Tag::NativeCode,
                 TagPayload::JSX => Tag::JSX,
                 TagPayload::Event => Tag::Event,
@@ -2087,6 +2090,7 @@
                 Tag::Promise => TagPayload::Promise,
                 Tag::JSON => TagPayload::JSON,
                 Tag::ToJSON => TagPayload::ToJSON,
+                Tag::Temporal => TagPayload::Temporal,
                 Tag::NativeCode => TagPayload::NativeCode,
                 Tag::JSX => TagPayload::JSX,
                 Tag::Event => TagPayload::Event,
@@ -2305,6 +2309,9 @@
                 T::JSDate => TagPayload::JSON,
                 T::JSPromise => TagPayload::Promise,
 
+                // Temporal cells are plain `ObjectType`; only ClassInfo tells them apart.
+                T::Object if value.is_temporal() => TagPayload::Temporal,
+
                 T::WrapForValidIterator
                 | T::RegExpStringIterator
                 | T::JSArrayIterator
@@ -3415,6 +3422,7 @@
                 Tag::Set => self.print_set::<ENABLE_ANSI_COLORS>(writer_, value),
                 Tag::ToJSON => self.print_to_json::<ENABLE_ANSI_COLORS>(writer_, value),
                 Tag::JSON => self.print_json::<ENABLE_ANSI_COLORS>(writer_, value, js_type),
+                Tag::Temporal => self.print_temporal::<ENABLE_ANSI_COLORS>(writer_, value),
                 Tag::Event => self.print_event::<ENABLE_ANSI_COLORS>(
                     writer_,
                     value,
@@ -4307,6 +4315,34 @@
             Ok(())
         }
 
+        /// `Temporal.PlainDate 2020-01-02` — label uncolored, `toString()` text
+        /// in Date's magenta; own properties and subclasses ignored like `Date`.
+        #[inline(never)]
+        fn print_temporal<const C: bool>(
+            &mut self,
+            writer_: &mut dyn bun_io::Write,
+            value: JSValue,
+        ) -> JsResult<()> {
+            let mut writer = WrappedWriter {
+                ctx: writer_,
+                failed: false,
+                estimated_line_length: &mut self.estimated_line_length,
+            };
+            let (label, str) = value.temporal_display_string(self.global_this)?;
+            writer.add_for_new_line(label.length() + 1 + str.length());
+            writer.print(format_args!(
+                "{} {}{}{}",
+                label,
+                pfmt!("<r><magenta>", C),
+                str,
+                pfmt!("<r>", C)
+            ));
+            if writer.failed {
+                self.failed = true;
+            }
+            Ok(())
+        }
+
         #[inline(never)]
         fn print_array<const C: bool>(
             &mut self,

src/jsc/JSValue.rs

@@ -1586,6 +1586,31 @@ impl JSValue {
             JSC__JSValue__jsonStringifyFast(self, global, out)
         })
     }
+
+    pub fn is_temporal(self) -> bool {
+        crate::cpp::Bun__JSValue__temporalObjectType(self) != 0
+    }
+
+    /// Requires `self.is_temporal()`. `(label, text)`, e.g.
+    /// `("Temporal.PlainDate", "2020-01-02")`: the class label and the value's
+    /// default-options `toString()`, read from internal slots.
+    pub fn temporal_display_string(
+        self,
+        global: &JSGlobalObject,
+    ) -> JsResult<(bun_core::String, bun_core::OwnedString)> {
+        let mut label = bun_core::String::empty();
+        let mut text = bun_core::OwnedString::new(bun_core::String::empty());
+        // SAFETY: both out-pointers are live `BunString`s the callee writes at most once.
+        unsafe {
+            crate::cpp::Bun__Temporal__toDisplayString(
+                global,
+                self,
+                &raw mut label,
+                &raw mut *text,
+            )?
+        };
+        Ok((label, text))
+    }
 }
 
 // ──────────────────────────────────────────────────────────────────────────

src/jsc/bindings/Temporal.cpp

@@ -0,0 +1,178 @@
+// Temporal value formatting shared by console.log/Bun.inspect, the test
+// runner's pretty-format, and util.inspect: each type's default-options spec
+// toString() text, built from internal slots, never from user-reachable code.
+
+#include "root.h"
+#include "Temporal.h"
+#include "headers-handwritten.h"
+
+#include "JavaScriptCore/ISO8601.h"
+#include "JavaScriptCore/JSCast.h"
+#include "JavaScriptCore/JSCJSValueInlines.h"
+#include "JavaScriptCore/JSGlobalObjectInlines.h"
+#include "JavaScriptCore/ObjectConstructor.h"
+#include "JavaScriptCore/TemporalCoreTypes.h"
+#include "JavaScriptCore/TemporalDuration.h"
+#include "JavaScriptCore/TemporalEnums.h"
+#include "JavaScriptCore/TemporalInstant.h"
+#include "JavaScriptCore/TemporalPlainDate.h"
+#include "JavaScriptCore/TemporalPlainDateTime.h"
+#include "JavaScriptCore/TemporalPlainMonthDay.h"
+#include "JavaScriptCore/TemporalPlainTime.h"
+#include "JavaScriptCore/TemporalPlainYearMonth.h"
+#include "JavaScriptCore/TemporalZonedDateTime.h"
+#include <wtf/text/StringBuilder.h>
+
+extern "C" [[ZIG_EXPORT(nothrow)]] uint8_t Bun__JSValue__temporalObjectType(JSC::EncodedJSValue encodedValue)
+{
+    JSC::JSValue value = JSC::JSValue::decode(encodedValue);
+    // Every Temporal class is a plain ObjectType cell; anything else short-circuits.
+    if (!value.isCell() || value.asCell()->type() != JSC::ObjectType)
+        return 0;
+    JSC::JSCell* cell = value.asCell();
+    if (cell->inherits<JSC::TemporalInstant>())
+        return 1;
+    if (cell->inherits<JSC::TemporalPlainDateTime>())
+        return 2;
+    if (cell->inherits<JSC::TemporalPlainDate>())
+        return 3;
+    if (cell->inherits<JSC::TemporalPlainTime>())
+        return 4;
+    if (cell->inherits<JSC::TemporalZonedDateTime>())
+        return 5;
+    if (cell->inherits<JSC::TemporalPlainYearMonth>())
+        return 6;
+    if (cell->inherits<JSC::TemporalPlainMonthDay>())
+        return 7;
+    if (cell->inherits<JSC::TemporalDuration>())
+        return 8;
+    return 0;
+}
+
+namespace Bun {
+
+static ASCIILiteral temporalLabel(uint8_t temporalType)
+{
+    switch (temporalType) {
+    case 1:
+        return "Temporal.Instant"_s;
+    case 2:
+        return "Temporal.PlainDateTime"_s;
+    case 3:
+        return "Temporal.PlainDate"_s;
+    case 4:
+        return "Temporal.PlainTime"_s;
+    case 5:
+        return "Temporal.ZonedDateTime"_s;
+    case 6:
+        return "Temporal.PlainYearMonth"_s;
+    case 7:
+        return "Temporal.PlainMonthDay"_s;
+    case 8:
+        return "Temporal.Duration"_s;
+    default:
+        RELEASE_ASSERT_NOT_REACHED();
+    }
+}
+
+// https://tc39.es/proposal-temporal/#sec-temporal-temporalzoneddatetimetostring
+// with every option ~auto~; JSC's own implementation is file-static in
+// TemporalZonedDateTimePrototype.cpp, so the recipe is replicated here.
+static WTF::String zonedDateTimeDisplayString(JSC::JSGlobalObject* globalObject, JSC::TemporalZonedDateTime* zonedDateTime)
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto [date, time] = zonedDateTime->getLocalDateTime(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    std::optional<int64_t> offsetOpt = zonedDateTime->getOffsetNanoseconds(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    WTF::StringBuilder builder;
+    builder.append(JSC::ISO8601::temporalDateTimeToString(date, time, { JSC::Precision::Auto, 0 }));
+
+    // FormatDateTimeUTCOffsetRounded: round the offset to the nearest minute.
+    int64_t offsetNs = *offsetOpt;
+    int64_t offsetMinutes = offsetNs / 60'000'000'000;
+    int64_t remainder = offsetNs % 60'000'000'000;
+    if (remainder > 30'000'000'000 || (remainder == 30'000'000'000 && offsetNs > 0))
+        offsetMinutes++;
+    else if (remainder < -30'000'000'000 || (remainder == -30'000'000'000 && offsetNs < 0))
+        offsetMinutes--;
+    builder.append(JSC::ISO8601::formatTimeZoneOffsetString(offsetMinutes * 60'000'000'000));
+
+    builder.append('[');
+    builder.append(zonedDateTime->timeZoneId());
+    builder.append(']');
+
+    if (!JSC::TemporalCore::calendarIsISO(zonedDateTime->calendarID())) {
+        builder.append("[u-ca="_s);
+        builder.append(zonedDateTime->calendarId());
+        builder.append(']');
+    }
+    return builder.toString();
+}
+
+// `temporalType` is the non-zero `Bun__JSValue__temporalObjectType(cell)`.
+static WTF::String temporalDisplayString(JSC::JSGlobalObject* globalObject, JSC::JSCell* cell, uint8_t temporalType)
+{
+    switch (temporalType) {
+    case 1:
+        return uncheckedDowncast<JSC::TemporalInstant>(cell)->toString();
+    case 2:
+        return uncheckedDowncast<JSC::TemporalPlainDateTime>(cell)->toString();
+    case 3:
+        return uncheckedDowncast<JSC::TemporalPlainDate>(cell)->toString();
+    case 4:
+        return uncheckedDowncast<JSC::TemporalPlainTime>(cell)->toString();
+    case 5:
+        return zonedDateTimeDisplayString(globalObject, uncheckedDowncast<JSC::TemporalZonedDateTime>(cell));
+    case 6:
+        return uncheckedDowncast<JSC::TemporalPlainYearMonth>(cell)->toString();
+    case 7:
+        return uncheckedDowncast<JSC::TemporalPlainMonthDay>(cell)->toString();
+    case 8:
+        return uncheckedDowncast<JSC::TemporalDuration>(cell)->toString(globalObject);
+    default:
+        RELEASE_ASSERT_NOT_REACHED();
+    }
+}
+
+} // namespace Bun
+
+// `encodedValue` must be a Temporal value (`Bun__JSValue__temporalObjectType` != 0).
+// Writes e.g. `Temporal.PlainDate` to `label` and `2020-01-02` to `text`.
+extern "C" [[ZIG_EXPORT(check_slow)]] void Bun__Temporal__toDisplayString(JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue encodedValue, BunString* label, BunString* text)
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    uint8_t temporalType = Bun__JSValue__temporalObjectType(encodedValue);
+    WTF::String string = Bun::temporalDisplayString(globalObject, JSC::JSValue::decode(encodedValue).asCell(), temporalType);
+    RETURN_IF_EXCEPTION(scope, );
+    *label = Bun::toStringView(Bun::temporalLabel(temporalType));
+    *text = Bun::toStringRef(string);
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionTemporalLabel, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    uint8_t temporalType = Bun__JSValue__temporalObjectType(JSC::JSValue::encode(callFrame->argument(0)));
+    if (!temporalType)
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    return JSC::JSValue::encode(JSC::jsNontrivialString(JSC::getVM(globalObject), Bun::temporalLabel(temporalType)));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionTemporalToDisplayString, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    JSC::JSValue value = callFrame->argument(0);
+    uint8_t temporalType = Bun__JSValue__temporalObjectType(JSC::JSValue::encode(value));
+    if (!temporalType)
+        return JSC::JSValue::encode(JSC::jsUndefined());
+
+    WTF::String result = Bun::temporalDisplayString(globalObject, value.asCell(), temporalType);
+    RETURN_IF_EXCEPTION(scope, {});
+    return JSC::JSValue::encode(JSC::jsString(vm, WTF::move(result)));
+}

src/jsc/bindings/Temporal.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "root.h"
+
+// 0 for non-Temporal values, otherwise 1 Instant, 2 PlainDateTime, 3 PlainDate,
+// 4 PlainTime, 5 ZonedDateTime, 6 PlainYearMonth, 7 PlainMonthDay, 8 Duration.
+extern "C" uint8_t Bun__JSValue__temporalObjectType(JSC::EncodedJSValue);
+
+// `jsFunctionTemporalLabel(value)` -> e.g. "Temporal.PlainDate", or undefined
+// if not Temporal.
+JSC_DECLARE_HOST_FUNCTION(jsFunctionTemporalLabel);
+// `jsFunctionTemporalToDisplayString(value)` -> the value's default-options
+// `toString()` text, or undefined if not Temporal.
+JSC_DECLARE_HOST_FUNCTION(jsFunctionTemporalToDisplayString);

src/jsc/bindings/bindings.cpp

@@ -108,6 +108,7 @@
 #include "JavaScriptCore/TemporalPlainYearMonth.h"
 #include "JavaScriptCore/TemporalZonedDateTime.h"
 #include "JavaScriptCore/TimeZoneICUBridge.h"
+#include "Temporal.h"
 
 #include "JavaScriptCore/FunctionPrototype.h"
 #include "JSFetchHeaders.h"
@@ -1067,18 +1068,6 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
     return true;
 }
 
-static bool isTemporalObject(JSC::JSObject* object)
-{
-    return object->inherits<JSC::TemporalInstant>()
-        || object->inherits<JSC::TemporalPlainDate>()
-        || object->inherits<JSC::TemporalPlainDateTime>()
-        || object->inherits<JSC::TemporalPlainTime>()
-        || object->inherits<JSC::TemporalZonedDateTime>()
-        || object->inherits<JSC::TemporalPlainYearMonth>()
-        || object->inherits<JSC::TemporalPlainMonthDay>()
-        || object->inherits<JSC::TemporalDuration>();
-}
-
 // Temporal objects keep their state in internal slots and have no own
 // properties, so the generic own-property walk would call any two instances
 // of a class equal. Compare the internal fields instead, the way JSDateType
@@ -1127,7 +1116,7 @@ static std::optional<bool> temporalObjectsDequal(JSC::JSObject* o1, JSC::JSObjec
     }
     // `o1` is not a Temporal object; a Temporal `o2` can then never be equal
     // (and must not reach the own-property walk).
-    if (isTemporalObject(o2))
+    if (Bun__JSValue__temporalObjectType(JSValue::encode(o2)))
         return false;
     return std::nullopt;
 }