console: lazy load process.stderr and process.stdout

This patch:
- Refactors the Console constructor: moves the property binding code
into and the writable streams binding code into two methods defined
on the Console.prototype with symbols.
- Refactors the global console creation: we only need to share the
property binding code from the Console constructor. To bind the
streams we can lazy load `process.stdio` and `process.stderr`
so that we don't create these streams when they are not used.
This significantly reduces the number of modules loaded during
bootstrap. Also, by calling the refactored-out method directly
we can skip the unnecessary typechecks when creating the global
console and there is no need to create a temporary Console
anymore.
- Refactors the error handler creation and the `write` method:
use a `kUseStdout` symbol to tell the internals which stream
should be loaded from the console instance. Also put the
`write` method on the Console prototype so it just loads
other properties directly off the console instance which simplifies
the call sites.
Also leaves a few TODOs for further refactoring of the console
bootstrap.
PR-URL: #24534
Reviewed-By: Gus Caplan <me@gus.host>

Author: joyeecheung

lib/console.js

@@ -65,7 +65,15 @@ const kFormatForStdout = Symbol('kFormatForStdout');
 constkGetInspectOptions=Symbol('kGetInspectOptions');
 constkColorMode=Symbol('kColorMode');
 constkIsConsole=Symbol('kIsConsole');
-
+constkWriteToConsole=Symbol('kWriteToConsole');
+constkBindProperties=Symbol('kBindProperties');
+constkBindStreamsEager=Symbol('kBindStreamsEager');
+constkBindStreamsLazy=Symbol('kBindStreamsLazy');
+constkUseStdout=Symbol('kUseStdout');
+constkUseStderr=Symbol('kUseStderr');
+
+// This constructor is not used to construct the global console.
+// It's exported for backwards compatibility.
 functionConsole(options/* or: stdout, stderr, ignoreErrors = true */){
 // We have to test new.target here to see if this function is called
 // with new, because we need to define a custom instanceof to accommodate
@@ -74,7 +82,6 @@ function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
 returnnewConsole(...arguments);
 }
 
-this[kIsConsole]=true;
 if(!options||typeofoptions.write==='function'){
 options={
 stdout: options,
@@ -97,37 +104,9 @@ function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
 thrownewERR_CONSOLE_WRITABLE_STREAM('stderr');
 }
 
-constprop={
-writable: true,
-enumerable: false,
-configurable: true
-};
-Object.defineProperty(this,'_stdout',{ ...prop,value: stdout});
-Object.defineProperty(this,'_stderr',{ ...prop,value: stderr});
-Object.defineProperty(this,'_ignoreErrors',{
- ...prop,
-value: Boolean(ignoreErrors),
-});
-Object.defineProperty(this,'_times',{ ...prop,value: newMap()});
-Object.defineProperty(this,'_stdoutErrorHandler',{
- ...prop,
-value: createWriteErrorHandler(stdout),
-});
-Object.defineProperty(this,'_stderrErrorHandler',{
- ...prop,
-value: createWriteErrorHandler(stderr),
-});
-
 if(typeofcolorMode!=='boolean'&&colorMode!=='auto')
 thrownewERR_INVALID_ARG_VALUE('colorMode',colorMode);
 
-// Corresponds to https://console.spec.whatwg.org/#count-map
-this[kCounts]=newMap();
-this[kColorMode]=colorMode;
-
-Object.defineProperty(this,kGroupIndent,{writable: true});
-this[kGroupIndent]='';
-
 // Bind the prototype functions to this Console instance
 varkeys=Object.keys(Console.prototype);
 for(varv=0;v<keys.length;v++){
@@ -137,14 +116,92 @@ function Console(options /* or: stdout, stderr, ignoreErrors = true */) {
 // from the prototype chain of the subclass.
 this[k]=this[k].bind(this);
 }
+
+this[kBindStreamsEager](stdout,stderr);
+this[kBindProperties](ignoreErrors,colorMode);
 }
 
+constconsolePropAttributes={
+writable: true,
+enumerable: false,
+configurable: true
+};
+
+// Fixup global.console instanceof global.console.Console
+Object.defineProperty(Console,Symbol.hasInstance,{
+value(instance){
+returninstance[kIsConsole];
+}
+});
+
+// Eager version for the Console constructor
+Console.prototype[kBindStreamsEager]=function(stdout,stderr){
+Object.defineProperties(this,{
+'_stdout': { ...consolePropAttributes,value: stdout},
+'_stderr': { ...consolePropAttributes,value: stderr}
+});
+};
+
+// Lazily load the stdout and stderr from an object so we don't
+// create the stdio streams when they are not even accessed
+Console.prototype[kBindStreamsLazy]=function(object){
+letstdout;
+letstderr;
+Object.defineProperties(this,{
+'_stdout': {
+enumerable: false,
+configurable: true,
+get(){
+if(!stdout)stdout=object.stdout;
+returnstdout;
+},
+set(value){stdout=value;}
+},
+'_stderr': {
+enumerable: false,
+configurable: true,
+get(){
+if(!stderr){stderr=object.stderr;}
+returnstderr;
+},
+set(value){stderr=value;}
+}
+});
+};
+
+Console.prototype[kBindProperties]=function(ignoreErrors,colorMode){
+Object.defineProperties(this,{
+'_stdoutErrorHandler': {
+ ...consolePropAttributes,
+value: createWriteErrorHandler(this,kUseStdout)
+},
+'_stderrErrorHandler': {
+ ...consolePropAttributes,
+value: createWriteErrorHandler(this,kUseStderr)
+},
+'_ignoreErrors': {
+ ...consolePropAttributes,
+value: Boolean(ignoreErrors)
+},
+'_times': { ...consolePropAttributes,value: newMap()}
+});
+
+// TODO(joyeecheung): use consolePropAttributes for these
+// Corresponds to https://console.spec.whatwg.org/#count-map
+this[kCounts]=newMap();
+this[kColorMode]=colorMode;
+this[kIsConsole]=true;
+this[kGroupIndent]='';
+};
+
 // Make a function that can serve as the callback passed to `stream.write()`.
-functioncreateWriteErrorHandler(stream){
+functioncreateWriteErrorHandler(instance,streamSymbol){
 return(err)=>{
 // This conditional evaluates to true if and only if there was an error
 // that was not already emitted (which happens when the _write callback
 // is invoked asynchronously).
+conststream=streamSymbol===kUseStdout ?
+instance._stdout : instance._stderr;
 if(err!==null&&!stream._writableState.errorEmitted){
 // If there was an error, it will be emitted on `stream` as
 // an `error` event. Adding a `once` listener will keep that error
@@ -158,7 +215,15 @@ function createWriteErrorHandler(stream) {
 };
 }
 
-functionwrite(ignoreErrors,stream,string,errorhandler,groupIndent){
+Console.prototype[kWriteToConsole]=function(streamSymbol,string){
+constignoreErrors=this._ignoreErrors;
+constgroupIndent=this[kGroupIndent];
+
+constuseStdout=streamSymbol===kUseStdout;
+conststream=useStdout ? this._stdout : this._stderr;
+consterrorHandler=useStdout ?
+this._stdoutErrorHandler : this._stderrErrorHandler;
+
 if(groupIndent.length!==0){
 if(string.indexOf('\n')!==-1){
 string=string.replace(/\n/g,`\n${groupIndent}`);
@@ -176,7 +241,7 @@ function write(ignoreErrors, stream, string, errorhandler, groupIndent) {
 // Add and later remove a noop error handler to catch synchronous errors.
 stream.once('error',noop);
 
-stream.write(string,errorhandler);
+stream.write(string,errorHandler);
 }catch(e){
 // Console is a debugging utility, so it swallowing errors is not desirable
 // even in edge cases such as low stack space.
@@ -186,7 +251,7 @@ function write(ignoreErrors, stream, string, errorhandler, groupIndent) {
 }finally{
 stream.removeListener('error',noop);
 }
-}
+};
 
 constkColorInspectOptions={colors: true};
 constkNoColorInspectOptions={};
@@ -212,23 +277,17 @@ Console.prototype[kFormatForStderr] = function(args) {
 };
 
 Console.prototype.log=functionlog(...args){
-write(this._ignoreErrors,
-this._stdout,
-this[kFormatForStdout](args),
-this._stdoutErrorHandler,
-this[kGroupIndent]);
+this[kWriteToConsole](kUseStdout,this[kFormatForStdout](args));
 };
+
 Console.prototype.debug=Console.prototype.log;
 Console.prototype.info=Console.prototype.log;
 Console.prototype.dirxml=Console.prototype.log;
 
 Console.prototype.warn=functionwarn(...args){
-write(this._ignoreErrors,
-this._stderr,
-this[kFormatForStderr](args),
-this._stderrErrorHandler,
-this[kGroupIndent]);
+this[kWriteToConsole](kUseStderr,this[kFormatForStderr](args));
 };
+
 Console.prototype.error=Console.prototype.warn;
 
 Console.prototype.dir=functiondir(object,options){
@@ -237,11 +296,7 @@ Console.prototype.dir = function dir(object, options) {
  ...this[kGetInspectOptions](this._stdout),
  ...options
 };
-write(this._ignoreErrors,
-this._stdout,
-util.inspect(object,options),
-this._stdoutErrorHandler,
-this[kGroupIndent]);
+this[kWriteToConsole](kUseStdout,util.inspect(object,options));
 };
 
 Console.prototype.time=functiontime(label='default'){
@@ -301,7 +356,7 @@ Console.prototype.trace = function trace(...args) {
 Console.prototype.assert=functionassert(expression, ...args){
 if(!expression){
 args[0]=`Assertion failed${args.length===0 ? '' : `: ${args[0]}`}`;
-this.warn(this[kFormatForStderr](args));
+this.warn(...args);// the arguments will be formatted in warn() again
 }
 };
 
@@ -363,7 +418,6 @@ const valuesKey = 'Values';
 constindexKey='(index)';
 constiterKey='(iteration index)';
 
-
 constisArray=(v)=>ArrayIsArray(v)||isTypedArray(v)||isBuffer(v);
 
 // https://console.spec.whatwg.org/#table
@@ -490,38 +544,31 @@ function noop() {}
 // we cannot actually use `new Console` to construct the global console.
 // Therefore, the console.Console.prototype is not
 // in the global console prototype chain anymore.
+
+// TODO(joyeecheung):
+// - Move the Console constructor into internal/console.js
+// - Move the global console creation code along with the inspector console
+// wrapping code in internal/bootstrap/node.js into a separate file.
+// - Make this file a simple re-export of those two files.
 // This is only here for v11.x conflict resolution.
 constglobalConsole=Object.create(Console.prototype);
-consttempConsole=newConsole({
-stdout: process.stdout,
-stderr: process.stderr
-});
 
 // Since Console is not on the prototype chain of the global console,
 // the symbol properties on Console.prototype have to be looked up from
-// the global console itself.
-for(constpropofObject.getOwnPropertySymbols(Console.prototype)){
-globalConsole[prop]=Console.prototype[prop];
-}
-
-// Reflect.ownKeys() is used here for retrieving Symbols
-for(constpropofReflect.ownKeys(tempConsole)){
-constdesc={ ...(Reflect.getOwnPropertyDescriptor(tempConsole,prop))};
-// Since Console would bind method calls onto the instance,
-// make sure the methods are called on globalConsole instead of
-// tempConsole.
-if(typeofConsole.prototype[prop]==='function'){
-desc.value=Console.prototype[prop].bind(globalConsole);
+// the global console itself. In addition, we need to make the global
+// console a namespace by binding the console methods directly onto
+// the global console with the receiver fixed.
+for(constpropofReflect.ownKeys(Console.prototype)){
+if(prop==='constructor'){continue;}
+constdesc=Reflect.getOwnPropertyDescriptor(Console.prototype,prop);
+if(typeofdesc.value==='function'){// fix the receiver
+desc.value=desc.value.bind(globalConsole);
 }
 Reflect.defineProperty(globalConsole,prop,desc);
 }
 
-globalConsole.Console=Console;
-
-Object.defineProperty(Console,Symbol.hasInstance,{
-value(instance){
-returninstance[kIsConsole];
-}
-});
+globalConsole[kBindStreamsLazy](process);
+globalConsole[kBindProperties](true,'auto');
 
 module.exports=globalConsole;
+module.exports.Console=Console;

test/parallel/test-bootstrap-modules.js

@@ -1,14 +1,16 @@
-/* eslint-disable node-core/required-modules */
-
+// Flags: --expose-internals
 'use strict';
 
-// Ordinarily test files must require('common') but that action causes
-// the global console to be compiled, defeating the purpose of this test.
-// This makes sure no additional files are added without carefully considering
-// lazy loading. Please adjust the value if necessary.
-
+// This list must be computed before we require any modules to
+// to eliminate the noise.
 constlist=process.moduleLoadList.slice();
 
+constcommon=require('../common');
 constassert=require('assert');
 
-assert(list.length<=78,list);
+constisMainThread=common.isMainThread;
+constkMaxModuleCount=isMainThread ? 56 : 78;
+
+assert(list.length<=kMaxModuleCount,
+`Total length: ${list.length}\n`+list.join('\n')
+);

test/pseudo-tty/test-stderr-stdout-handle-sigwinch.out

@@ -1,2 +1,2 @@
-calling stdout._refreshSize
 calling stderr._refreshSize
+calling stdout._refreshSize