errors: improve performance of instantiation

PR-URL: #49654
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Raz Luvaton <rluvaton@gmail.com>

Author: Uzlopak

benchmark/misc/hidestackframes.js benchmark/error/hidestackframes.jsbenchmark/misc/hidestackframes.js renamed to benchmark/error/hidestackframes.js

@@ -0,0 +1,66 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('assert');
+
+constbench=common.createBenchmark(main,{
+n: [1e6],
+code: [
+'built-in',
+'ERR_HTTP2_STREAM_SELF_DEPENDENCY',
+'ERR_INVALID_STATE',
+'ERR_INVALID_URL',
+],
+stackTraceLimit: [0,10],
+},{
+flags: ['--expose-internals'],
+});
+
+functiongetErrorFactory(code){
+const{
+ERR_HTTP2_STREAM_SELF_DEPENDENCY,
+ERR_INVALID_STATE,
+ERR_INVALID_URL,
+}=require('internal/errors').codes;
+
+switch(code){
+case'built-in':
+return(n)=>newError();
+case'ERR_HTTP2_STREAM_SELF_DEPENDENCY':
+return(n)=>newERR_HTTP2_STREAM_SELF_DEPENDENCY();
+case'ERR_INVALID_STATE':
+return(n)=>newERR_INVALID_STATE(n+'');
+case'ERR_INVALID_URL':
+return(n)=>newERR_INVALID_URL({input: n+''});
+default:
+thrownewError(`${code} not supported`);
+}
+}
+
+functionmain({ n, code, stackTraceLimit }){
+constgetError=getErrorFactory(code);
+
+Error.stackTraceLimit=stackTraceLimit;
+
+// Warm up.
+constlength=1024;
+constarray=[];
+for(leti=0;i<length;++i){
+array.push(getError(i));
+}
+
+bench.start();
+
+for(leti=0;i<n;++i){
+constindex=i%length;
+array[index]=getError(index);
+}
+
+bench.end(n);
+
+// Verify the entries to prevent dead code elimination from making
+// the benchmark invalid.
+for(leti=0;i<length;++i){
+assert.strictEqual(typeofarray[i],'object');
+}
+}

benchmark/error/node-error-instantiation.js

@@ -0,0 +1,62 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('assert');
+
+constbench=common.createBenchmark(main,{
+n: [1e6],
+code: [
+'built-in',
+'ERR_HTTP2_STREAM_SELF_DEPENDENCY',
+'ERR_INVALID_STATE',
+],
+stackTraceLimit: [0,10],
+},{
+flags: ['--expose-internals'],
+});
+
+functiongetErrorStackFactory(code){
+const{
+ERR_INVALID_STATE,
+ERR_HTTP2_STREAM_SELF_DEPENDENCY,
+}=require('internal/errors').codes;
+
+switch(code){
+case'built-in':
+return(n)=>newError().stack;
+case'ERR_HTTP2_STREAM_SELF_DEPENDENCY':
+return(n)=>newERR_HTTP2_STREAM_SELF_DEPENDENCY().stack;
+case'ERR_INVALID_STATE':
+return(n)=>newERR_INVALID_STATE(n+'').stack;
+default:
+thrownewError(`${code} not supported`);
+}
+}
+
+functionmain({ n, code, stackTraceLimit }){
+constgetStack=getErrorStackFactory(code);
+
+Error.stackTraceLimit=stackTraceLimit;
+
+// Warm up.
+constlength=1024;
+constarray=[];
+for(leti=0;i<length;++i){
+array.push(getStack(i));
+}
+
+bench.start();
+
+for(leti=0;i<n;++i){
+constindex=i%length;
+array[index]=getStack(index);
+}
+
+bench.end(n);
+
+// Verify the entries to prevent dead code elimination from making
+// the benchmark invalid.
+for(leti=0;i<length;++i){
+assert.strictEqual(typeofarray[i],'string');
+}
+}

benchmark/error/node-error-stack.js

@@ -57,7 +57,7 @@ const validateParameters = hideStackFrames((hash, key, salt, info, length) => {
 validateInteger(length,'length',0,kMaxLength);
 
 if(info.byteLength>1024){
-throwERR_OUT_OF_RANGE(
+thrownewERR_OUT_OF_RANGE(
 'info',
 'must not contain more than 1024 bytes',
 info.byteLength);

benchmark/error/node-error.js

@@ -175,9 +175,10 @@ const aggregateErrors = hideStackFrames((errors, message, code) => {
 returnerr;
 });
 
+constassert=require('internal/assert');
+
 // Lazily loaded
 letutil;
-letassert;
 
 letinternalUtil=null;
 functionlazyInternalUtil(){
@@ -371,42 +372,103 @@ function makeSystemErrorWithCode(key) {
 }
 
 functionmakeNodeErrorWithCode(Base,key){
-returnfunctionNodeError(...args){
-constlimit=Error.stackTraceLimit;
-if(isErrorStackTraceLimitWritable())Error.stackTraceLimit=0;
-consterror=newBase();
-// Reset the limit and setting the name property.
-if(isErrorStackTraceLimitWritable())Error.stackTraceLimit=limit;
-constmessage=getMessage(key,args,error);
-ObjectDefineProperties(error,{
-[kIsNodeError]: {
-__proto__: null,
-value: true,
-enumerable: false,
-writable: false,
-configurable: true,
-},
-message: {
-__proto__: null,
-value: message,
-enumerable: false,
-writable: true,
-configurable: true,
-},
-toString: {
-__proto__: null,
-value(){
+constmsg=messages.get(key);
+constexpectedLength=typeofmsg!=='string' ? -1 : getExpectedArgumentLength(msg);
+
+switch(expectedLength){
+case0: {
+classNodeErrorextendsBase{
+code=key;
+
+constructor(...args){
+assert(
+args.length===0,
+`Code: ${key}; The provided arguments length (${args.length}) does not `+
+`match the required ones (${expectedLength}).`,
+);
+super(msg);
+}
+
+// This is a workaround for wpt tests that expect that the error
+// constructor has a `name` property of the base class.
+get['constructor'](){
+returnBase;
+}
+
+get[kIsNodeError](){
+returntrue;
+}
+
+toString(){
 return`${this.name} [${key}]: ${this.message}`;
-},
-enumerable: false,
-writable: true,
-configurable: true,
-},
-});
-captureLargerStackTrace(error);
-error.code=key;
-returnerror;
-};
+}
+}
+returnNodeError;
+}
+case-1: {
+classNodeErrorextendsBase{
+code=key;
+
+constructor(...args){
+super();
+ObjectDefineProperty(this,'message',{
+__proto__: null,
+value: getMessage(key,args,this),
+enumerable: false,
+writable: true,
+configurable: true,
+});
+}
+
+// This is a workaround for wpt tests that expect that the error
+// constructor has a `name` property of the base class.
+get['constructor'](){
+returnBase;
+}
+
+get[kIsNodeError](){
+returntrue;
+}
+
+toString(){
+return`${this.name} [${key}]: ${this.message}`;
+}
+}
+returnNodeError;
+}
+default: {
+
+classNodeErrorextendsBase{
+code=key;
+
+constructor(...args){
+assert(
+args.length===expectedLength,
+`Code: ${key}; The provided arguments length (${args.length}) does not `+
+`match the required ones (${expectedLength}).`,
+);
+
+ArrayPrototypeUnshift(args,msg);
+super(ReflectApply(lazyInternalUtilInspect().format,null,args));
+}
+
+// This is a workaround for wpt tests that expect that the error
+// constructor has a `name` property of the base class.
+get['constructor'](){
+returnBase;
+}
+
+get[kIsNodeError](){
+returntrue;
+}
+
+toString(){
+return`${this.name} [${key}]: ${this.message}`;
+}
+}
+returnNodeError;
+}
+}
 }
 
 /**
@@ -443,11 +505,16 @@ function E(sym, val, def, ...otherClasses) {
 codes[sym]=def;
 }
 
+functiongetExpectedArgumentLength(msg){
+letexpectedLength=0;
+constregex=/%[dfijoOs]/g;
+while(RegExpPrototypeExec(regex,msg)!==null)expectedLength++;
+returnexpectedLength;
+}
+
 functiongetMessage(key,args,self){
 constmsg=messages.get(key);
 
-assert??=require('internal/assert');
-
 if(typeofmsg==='function'){
 assert(
 msg.length<=args.length,// Default options do not count.
@@ -457,9 +524,7 @@ function getMessage(key, args, self) {
 returnReflectApply(msg,self,args);
 }
 
-constregex=/%[dfijoOs]/g;
-letexpectedLength=0;
-while(RegExpPrototypeExec(regex,msg)!==null)expectedLength++;
+constexpectedLength=getExpectedArgumentLength(msg);
 assert(
 expectedLength===args.length,
 `Code: ${key}; The provided arguments length (${args.length}) does not `+
@@ -1476,8 +1541,7 @@ E('ERR_NETWORK_IMPORT_DISALLOWED',
 "import of '%s' by %s is not supported: %s",Error);
 E('ERR_NOT_BUILDING_SNAPSHOT',
 'Operation cannot be invoked when not building startup snapshot',Error);
-E('ERR_NOT_SUPPORTED_IN_SNAPSHOT',
-'%s is not supported in startup snapshot',Error);
+E('ERR_NOT_SUPPORTED_IN_SNAPSHOT','%s is not supported in startup snapshot',Error);
 E('ERR_NO_CRYPTO',
 'Node.js is not compiled with OpenSSL crypto support',Error);
 E('ERR_NO_ICU',

lib/internal/crypto/hkdf.js

@@ -143,8 +143,8 @@ function importFd(stream, options) {
 returnoptions.fd.fd;
 }
 
-throwERR_INVALID_ARG_TYPE('options.fd',
-['number','FileHandle'],options.fd);
+thrownewERR_INVALID_ARG_TYPE('options.fd',
+['number','FileHandle'],options.fd);
 }
 
 functionReadStream(path,options){

lib/internal/errors.js

@@ -471,7 +471,7 @@ class Hooks {
 !isAnyArrayBuffer(source)&&
 !isArrayBufferView(source)
 ){
-throwERR_INVALID_RETURN_PROPERTY_VALUE(
+thrownewERR_INVALID_RETURN_PROPERTY_VALUE(
 'a string, an ArrayBuffer, or a TypedArray',
 hookErrIdentifier,
 'source',
@@ -662,7 +662,7 @@ class HooksProxy {
 if(status==='error'){
 if(body==null||typeofbody!=='object'){throwbody;}
 if(body.serializationFailed||body.serialized==null){
-throwERR_WORKER_UNSERIALIZABLE_ERROR();
+thrownewERR_WORKER_UNSERIALIZABLE_ERROR();
 }
 
 // eslint-disable-next-line no-restricted-syntax

lib/internal/fs/streams.js

@@ -847,7 +847,7 @@ class URL {
 sethref(value){
 value=`${value}`;
 consthref=bindingUrl.update(this.#context.href,updateActions.kHref,value);
-if(!href){throwERR_INVALID_URL(value);}
+if(!href){thrownewERR_INVALID_URL(value);}
 this.#updateContext(href);
 }