src: implement util.types fast API calls

BridgeAR · BridgeAR · commit 5770181b69df · 2025-04-10T15:19:51.000+02:00
All util.types.is##Type() calls are ported to the fast API.

This improves the performance for multiple APIs such as:

- util.inspect (and util.format and console methods respectively)
- util.isDeepStrictEqual
- assert.(not)deepEqual (including strict and partial mode)

It will also improve any other API where these APIs are used.
diff --git a/src/node_types.cc b/src/node_types.cc
@@ -2,6 +2,7 @@
 #include "node.h"
 #include "node_external_reference.h"
 
+using v8::CFunction;
 using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::Local;
@@ -42,7 +43,11 @@ namespace {
 #define V(type) \
   static void Is##type(const FunctionCallbackInfo<Value>& args) {             \
     args.GetReturnValue().Set(args[0]->Is##type());                           \
-  }
+  }                                                                           \
+  static bool Is##type##FastApi(Local<Value> unused, Local<Value> receiver) { \
+    return receiver->Is##type();                                              \
+  }                                                                           \
+  static CFunction fast_is_##type##_ = CFunction::Make(Is##type##FastApi);
 
   VALUE_METHOD_MAP(V)
 #undef V
@@ -52,6 +57,14 @@ static void IsAnyArrayBuffer(const FunctionCallbackInfo<Value>& args) {
     args[0]->IsArrayBuffer() || args[0]->IsSharedArrayBuffer());
 }
 
+static bool IsAnyArrayBufferFastApi(Local<Value> unused,
+                                    Local<Value> receiver) {
+  return receiver->IsArrayBuffer() || receiver->IsSharedArrayBuffer();
+}
+
+static CFunction fast_is_any_array_buffer_ =
+  CFunction::Make(IsAnyArrayBufferFastApi);
+
 static void IsBoxedPrimitive(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(
     args[0]->IsNumberObject() ||
@@ -61,27 +74,52 @@ static void IsBoxedPrimitive(const FunctionCallbackInfo<Value>& args) {
     args[0]->IsSymbolObject());
 }
 
+static bool IsBoxedPrimitiveFastApi(Local<Value> unused,
+                                    Local<Value> receiver) {
+  return receiver->IsNumberObject() ||
+         receiver->IsStringObject() ||
+         receiver->IsBooleanObject() ||
+         receiver->IsBigIntObject() ||
+         receiver->IsSymbolObject();
+}
+
+static CFunction fast_is_boxed_primitive_ =
+  CFunction::Make(IsBoxedPrimitiveFastApi);
+
 void InitializeTypes(Local<Object> target,
                      Local<Value> unused,
                      Local<Context> context,
                      void* priv) {
-#define V(type) SetMethodNoSideEffect(context, target, "is" #type, Is##type);
+#define V(type) \
+  SetFastMethodNoSideEffect(context, target, "is" #type,                      \
+                            Is##type, &fast_is_##type##_);
+
   VALUE_METHOD_MAP(V)
 #undef V
 
-  SetMethodNoSideEffect(context, target, "isAnyArrayBuffer", IsAnyArrayBuffer);
-  SetMethodNoSideEffect(context, target, "isBoxedPrimitive", IsBoxedPrimitive);
+  SetFastMethodNoSideEffect(context, target, "isAnyArrayBuffer",
+                            IsAnyArrayBuffer, &fast_is_any_array_buffer_);
+  SetFastMethodNoSideEffect(context, target, "isBoxedPrimitive",
+                            IsBoxedPrimitive, &fast_is_boxed_primitive_);
 }
 
 }  // anonymous namespace
 
 void RegisterTypesExternalReferences(ExternalReferenceRegistry* registry) {
-#define V(type) registry->Register(Is##type);
+#define V(type) \
+  registry->Register(Is##type);                                               \
+  registry->Register(Is##type##FastApi);                                      \
+  registry->Register(fast_is_##type##_.GetTypeInfo());
+
   VALUE_METHOD_MAP(V)
 #undef V
 
   registry->Register(IsAnyArrayBuffer);
+  registry->Register(IsAnyArrayBufferFastApi);
+  registry->Register(fast_is_any_array_buffer_.GetTypeInfo());
   registry->Register(IsBoxedPrimitive);
+  registry->Register(IsBoxedPrimitiveFastApi);
+  registry->Register(fast_is_boxed_primitive_.GetTypeInfo());
 }
 }  // namespace node
 
