domain: set .domain non-enumerable on resources

In particular, this comes into play in the node repl, which apparently
enables domains by default. Whenever any Promise gets inspected, a
`.domain` property is displayed, which is *very confusing*, especially
since it has some kind of WeakReference attached to it, which is not yet
a language feature.
This change will prevent it from showing up in casual inspection, but
will leave it available for use.
PR-URL: #26210
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Сковорода Никита Андреевич <chalkerx@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>

Author: ljharb

lib/domain.js

@@ -58,13 +58,23 @@ const asyncHook = createHook({
 if(process.domain!==null&&process.domain!==undefined){
 // If this operation is created while in a domain, let's mark it
 pairing.set(asyncId,process.domain[kWeak]);
-resource.domain=process.domain;
+Object.defineProperty(resource,'domain',{
+configurable: true,
+enumerable: false,
+value: process.domain,
+writable: true
+});
 if(resource.promise!==undefined&&
 resource.promiseinstanceofPromise){
 // resource.promise instanceof Promise make sure that the
 // promise comes from the same context
 // see https://github.com/nodejs/node/issues/15673
-resource.promise.domain=process.domain;
+Object.defineProperty(resource.promise,'domain',{
+configurable: true,
+enumerable: false,
+value: process.domain,
+writable: true
+});
 }
 }
 },
@@ -203,7 +213,12 @@ Domain.prototype._errorHandler = function(er) {
 varcaught=false;
 
 if(!util.isPrimitive(er)){
-er.domain=this;
+Object.defineProperty(er,'domain',{
+configurable: true,
+enumerable: false,
+value: this,
+writable: true
+});
 er.domainThrown=true;
 }
 
@@ -320,7 +335,12 @@ Domain.prototype.add = function(ee) {
 }
 }
 
-ee.domain=this;
+Object.defineProperty(ee,'domain',{
+configurable: true,
+enumerable: false,
+value: this,
+writable: true
+});
 this.members.push(ee);
 };
 
@@ -359,7 +379,12 @@ function intercepted(_this, self, cb, fnargs) {
 varer=fnargs[0];
 er.domainBound=cb;
 er.domainThrown=false;
-er.domain=self;
+Object.defineProperty(er,'domain',{
+configurable: true,
+enumerable: false,
+value: self,
+writable: true
+});
 self.emit('error',er);
 return;
 }
@@ -413,7 +438,12 @@ Domain.prototype.bind = function(cb) {
 returnbound(this,self,cb,arguments);
 }
 
-runBound.domain=this;
+Object.defineProperty(runBound,'domain',{
+configurable: true,
+enumerable: false,
+value: this,
+writable: true
+});
 
 returnrunBound;
 };
@@ -423,7 +453,12 @@ EventEmitter.usingDomains = true;
 
 consteventInit=EventEmitter.init;
 EventEmitter.init=function(){
-this.domain=null;
+Object.defineProperty(this,'domain',{
+configurable: true,
+enumerable: false,
+value: null,
+writable: true
+});
 if(exports.active&&!(thisinstanceofexports.Domain)){
 this.domain=exports.active;
 }
@@ -452,7 +487,12 @@ EventEmitter.prototype.emit = function(...args) {
 
 if(typeofer==='object'){
 er.domainEmitter=this;
-er.domain=domain;
+Object.defineProperty(er,'domain',{
+configurable: true,
+enumerable: false,
+value: domain,
+writable: true
+});
 er.domainThrown=false;
 }
 

test/parallel/test-domain-add-remove.js

@@ -4,13 +4,15 @@ require('../common');
 constassert=require('assert');
 constdomain=require('domain');
 constEventEmitter=require('events');
+constisEnumerable=Function.call.bind(Object.prototype.propertyIsEnumerable);
 
 constd=newdomain.Domain();
 conste=newEventEmitter();
 conste2=newEventEmitter();
 
 d.add(e);
 assert.strictEqual(e.domain,d);
+assert.strictEqual(isEnumerable(e,'domain'),false);
 
 // Adding the same event to a domain should not change the member count
 letpreviousMemberCount=d.members.length;
@@ -19,8 +21,10 @@ assert.strictEqual(previousMemberCount, d.members.length);
 
 d.add(e2);
 assert.strictEqual(e2.domain,d);
+assert.strictEqual(isEnumerable(e2,'domain'),false);
 
 previousMemberCount=d.members.length;
 d.remove(e2);
 assert.notStrictEqual(e2.domain,d);
+assert.strictEqual(isEnumerable(e2,'domain'),false);
 assert.strictEqual(previousMemberCount-1,d.members.length);

test/parallel/test-domain-async-id-map-leak.js

@@ -6,6 +6,7 @@ const assert = require('assert');
 constasync_hooks=require('async_hooks');
 constdomain=require('domain');
 constEventEmitter=require('events');
+constisEnumerable=Function.call.bind(Object.prototype.propertyIsEnumerable);
 
 // This test makes sure that the (async id → domain) map which is part of the
 // domain module does not get in the way of garbage collection.
@@ -21,7 +22,9 @@ d.run(() => {
 
 emitter.linkToResource=resource;
 assert.strictEqual(emitter.domain,d);
+assert.strictEqual(isEnumerable(emitter,'domain'),false);
 assert.strictEqual(resource.domain,d);
+assert.strictEqual(isEnumerable(resource,'domain'),false);
 
 // This would otherwise be a circular chain now:
 // emitter → resource → async id ⇒ domain → emitter.

test/parallel/test-domain-implicit-binding.js

@@ -4,13 +4,15 @@ const common = require('../common');
 constassert=require('assert');
 constdomain=require('domain');
 constfs=require('fs');
+constisEnumerable=Function.call.bind(Object.prototype.propertyIsEnumerable);
 
 {
 constd=newdomain.Domain();
 
 d.on('error',common.mustCall((err)=>{
 assert.strictEqual(err.message,'foobar');
 assert.strictEqual(err.domain,d);
+assert.strictEqual(isEnumerable(err,'domain'),false);
 assert.strictEqual(err.domainEmitter,undefined);
 assert.strictEqual(err.domainBound,undefined);
 assert.strictEqual(err.domainThrown,true);

test/parallel/test-domain-timer.js

@@ -3,12 +3,14 @@
 constcommon=require('../common');
 constassert=require('assert');
 constdomain=require('domain');
+constisEnumerable=Function.call.bind(Object.prototype.propertyIsEnumerable);
 
 constd=newdomain.Domain();
 
 d.on('error',common.mustCall((err)=>{
 assert.strictEqual(err.message,'foobar');
 assert.strictEqual(err.domain,d);
+assert.strictEqual(isEnumerable(err,'domain'),false);
 assert.strictEqual(err.domainEmitter,undefined);
 assert.strictEqual(err.domainBound,undefined);
 assert.strictEqual(err.domainThrown,true);