util: capture Temporal state in pre-execution

Signed-off-by: Renegade334 <contact.9a5d6388@renegade334.me.uk>

Author: Renegade334

lib/internal/process/pre_execution.js

@@ -138,6 +138,8 @@ function prepareExecution(options) {
 
   require('internal/dns/utils').initializeDns();
 
+  require('internal/util/temporal').initialize();
+
   if (isMainThread) {
     assert(internalBinding('worker').isMainThread);
     // Worker threads will get the manifest in the message handler.

lib/internal/util/inspect.js

@@ -195,6 +195,8 @@ const {
   kValidateObjectAllowArray,
 } = require('internal/validators');
 
+const temporal = require('internal/util/temporal');
+
 let hexSlice;
 let internalUrl;
 
@@ -208,40 +210,6 @@ function isURL(value) {
   return typeof value.href === 'string' && value instanceof internalUrl.URL;
 }
 
-const temporalConstructors = [
-  { name: 'Duration', fullName: 'Temporal.Duration' },
-  { name: 'Instant', fullName: 'Temporal.Instant' },
-  { name: 'PlainDate', fullName: 'Temporal.PlainDate' },
-  { name: 'PlainDateTime', fullName: 'Temporal.PlainDateTime' },
-  { name: 'PlainMonthDay', fullName: 'Temporal.PlainMonthDay' },
-  { name: 'PlainTime', fullName: 'Temporal.PlainTime' },
-  { name: 'PlainYearMonth', fullName: 'Temporal.PlainYearMonth' },
-  { name: 'ZonedDateTime', fullName: 'Temporal.ZonedDateTime' },
-];
-
-// Best-effort, using instanceof. Polyfills will likely pass these checks.
-// TODO: Hopefully the V8 API will expose typechecks at some point.
-function getTemporalInfo(value) {
-  try {
-    const { Temporal } = globalThis;
-    if (Temporal != null) {
-      for (let i = 0; i < temporalConstructors.length; i++) {
-        const entry = temporalConstructors[i];
-        const constructor = Temporal[entry.name];
-        if (typeof constructor !== 'function' || !FunctionPrototypeSymbolHasInstance(constructor, value)) {
-          continue;
-        }
-        const { prototype } = constructor;
-        if (!ObjectPrototypeHasOwnProperty(prototype, 'toString')) {
-          return;
-        }
-        const result = FunctionPrototypeCall(prototype.toString, value);
-        return { ...entry, result };
-      }
-    }
-  } catch { /* void */ }
-}
-
 const builtInObjects = new SafeSet(
   ArrayPrototypeFilter(
     ObjectGetOwnPropertyNames(globalThis),
@@ -1355,7 +1323,6 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
   if (noIterator) {
     keys = getKeys(value, ctx.showHidden);
     braces = ['{', '}'];
-    let temporalInfo;
     if (typeof value === 'function') {
       base = getFunctionBase(ctx, value, constructor, tag);
       if (keys.length === 0 && protoProps === undefined)
@@ -1439,11 +1406,67 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
       if (keys.length === 0 && protoProps === undefined) {
         return base;
       }
-    } else if ((temporalInfo = getTemporalInfo(value))) {
-      const prefix = constructor === temporalInfo.name && tag === temporalInfo.fullName ?
-        (temporalInfo.fullName + ' ') :
-        getPrefix(constructor, tag, temporalInfo.fullName);
-      base = `${prefix}${temporalInfo.result}`;
+    } else if (temporal.isTemporalDuration(value)) {
+      const prefix = constructor === 'Duration' && tag === 'Temporal.Duration' ?
+        ('Temporal.Duration ') :
+        getPrefix(constructor, tag, 'Temporal.Duration');
+      base = `${prefix}${temporal.TemporalDurationPrototypeToString(value)}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, 'date');
+      }
+    } else if (temporal.isTemporalInstant(value)) {
+      const prefix = constructor === 'Instant' && tag === 'Temporal.Instant' ?
+        ('Temporal.Instant ') :
+        getPrefix(constructor, tag, 'Temporal.Instant');
+      base = `${prefix}${temporal.TemporalInstantPrototypeToString(value)}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, 'date');
+      }
+    } else if (temporal.isTemporalPlainDate(value)) {
+      const prefix = constructor === 'PlainDate' && tag === 'Temporal.PlainDate' ?
+        ('Temporal.PlainDate ') :
+        getPrefix(constructor, tag, 'Temporal.PlainDate');
+      base = `${prefix}${temporal.TemporalPlainDatePrototypeToString(value)}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, 'date');
+      }
+    } else if (temporal.isTemporalPlainDateTime(value)) {
+      const prefix = constructor === 'PlainDateTime' && tag === 'Temporal.PlainDateTime' ?
+        ('Temporal.PlainDateTime ') :
+        getPrefix(constructor, tag, 'Temporal.PlainDateTime');
+      base = `${prefix}${temporal.TemporalPlainDateTimePrototypeToString(value)}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, 'date');
+      }
+    } else if (temporal.isTemporalPlainMonthDay(value)) {
+      const prefix = constructor === 'PlainMonthDay' && tag === 'Temporal.PlainMonthDay' ?
+        ('Temporal.PlainMonthDay ') :
+        getPrefix(constructor, tag, 'Temporal.PlainMonthDay');
+      base = `${prefix}${temporal.TemporalPlainMonthDayPrototypeToString(value)}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, 'date');
+      }
+    } else if (temporal.isTemporalPlainTime(value)) {
+      const prefix = constructor === 'PlainTime' && tag === 'Temporal.PlainTime' ?
+        ('Temporal.PlainTime ') :
+        getPrefix(constructor, tag, 'Temporal.PlainTime');
+      base = `${prefix}${temporal.TemporalPlainTimePrototypeToString(value)}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, 'date');
+      }
+    } else if (temporal.isTemporalPlainYearMonth(value)) {
+      const prefix = constructor === 'PlainYearMonth' && tag === 'Temporal.PlainYearMonth' ?
+        ('Temporal.PlainYearMonth ') :
+        getPrefix(constructor, tag, 'Temporal.PlainYearMonth');
+      base = `${prefix}${temporal.TemporalPlainYearMonthPrototypeToString(value)}`;
+      if (keys.length === 0 && protoProps === undefined) {
+        return ctx.stylize(base, 'date');
+      }
+    } else if (temporal.isTemporalZonedDateTime(value)) {
+      const prefix = constructor === 'ZonedDateTime' && tag === 'Temporal.ZonedDateTime' ?
+        ('Temporal.ZonedDateTime ') :
+        getPrefix(constructor, tag, 'Temporal.ZonedDateTime');
+      base = `${prefix}${temporal.TemporalZonedDateTimePrototypeToString(value)}`;
       if (keys.length === 0 && protoProps === undefined) {
         return ctx.stylize(base, 'date');
       }

lib/internal/util/temporal.js

@@ -0,0 +1,101 @@
+'use strict';
+
+// This module is initialized in the pre-execution phase, before user code is
+// run. Since the module namespace is not populated at snapshot time, this
+// module should be not be imported with a destructuring pattern unless
+// imported lazily.
+
+// TODO(Renegade334): Remove typecheck methods once available via V8 API.
+// Replace with primordials if/when temporal_rs becomes a mandatory V8
+// build dependency and the harmony_temporal flag is removed.
+
+const {
+  ArrayPrototypeForEach,
+  FunctionPrototypeCall,
+  ObjectEntries,
+  ObjectGetOwnPropertyDescriptors,
+  SafeMap,
+  StringPrototypeSubstring,
+  StringPrototypeToUpperCase,
+  globalThis,
+  uncurryThis,
+} = primordials;
+
+// The keys of this Map are the Temporal constructor names.
+// The values are the names of the most lightweight brand-aware getter within
+// each prototype, which can be called speculatively as a brand check.
+const constructors = new SafeMap()
+    .set('Duration', 'nanoseconds')
+    .set('Instant', 'epochNanoseconds')
+    .set('PlainDate', 'calendarId')
+    .set('PlainDateTime', 'calendarId')
+    .set('PlainMonthDay', 'calendarId')
+    .set('PlainTime', 'nanosecond')
+    .set('PlainYearMonth', 'calendarId')
+    .set('ZonedDateTime', 'calendarId');
+
+exports.initialize = () => {
+  const { Temporal } = globalThis;
+  if (typeof Temporal === 'undefined') {
+    for (const name of constructors.keys()) {
+      exports[`isTemporal${name}`] = () => false;
+    }
+    return;
+  }
+
+  for (const { 0: name, 1: brandedGetter } of constructors.entries()) {
+    const constructor = Temporal[name];
+    exports[`Temporal${name}`] = constructor;
+
+    ArrayPrototypeForEach(
+      ObjectEntries(ObjectGetOwnPropertyDescriptors(constructor)),
+      ({ 0: key, 1: desc }) => {
+        if (typeof key !== 'string' || typeof desc.value !== 'function') return;
+
+        exports[`Temporal${name}${capitalizeKey(key)}`] = desc.value;
+      },
+    );
+
+    ArrayPrototypeForEach(
+      ObjectEntries(ObjectGetOwnPropertyDescriptors(constructor.prototype)),
+      ({ 0: key, 1: desc }) => {
+        if (typeof key !== 'string') return;
+
+        if ('get' in desc) {
+          exports[`Temporal${name}PrototypeGet${capitalizeKey(key)}`] = uncurryThis(desc.get);
+          if (key === brandedGetter) {
+            exports[`isTemporal${name}`] = makeTypeCheckMethod(desc.get);
+          }
+        } else {
+          exports[`Temporal${name}Prototype${capitalizeKey(key)}`] = typeof desc.value === 'function' ?
+            uncurryThis(desc.value) :
+            desc.value;
+        }
+      },
+    );
+  }
+
+  ArrayPrototypeForEach(
+    ObjectEntries(ObjectGetOwnPropertyDescriptors(Temporal.Now)),
+    ({ 0: key, 1: desc }) => {
+      if (typeof key !== 'string' || !('value' in desc)) return;
+
+      exports[`TemporalNow${capitalizeKey(key)}`] = desc.value;
+    },
+  );
+};
+
+function makeTypeCheckMethod(getter) {
+  return (value) => {
+    try {
+      FunctionPrototypeCall(getter, value);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
+
+function capitalizeKey(key) {
+  return `${StringPrototypeToUpperCase(key[0])}${StringPrototypeSubstring(key, 1)}`;
+}