lib: make the global console [[Prototype]] an empty object

From the WHATWG console spec:

> For historical web-compatibility reasons, the namespace object for
> console must have as its [[Prototype]] an empty object, created as
> if by ObjectCreate(%ObjectPrototype%), instead of %ObjectPrototype%.

Since in Node.js, the Console constructor has been exposed through
require('console'), we need to keep the Console constructor but
we cannot actually use `new Console` to construct the global console.

This patch changes the prototype chain of the global console object,
so the console.Console.prototype is not in the global console prototype
chain anymore.

```
const proto = Object.getPrototypeOf(global.console);
// Before this patch
proto.constructor === global.console.Console
// After this patch
proto.constructor === Object
```

But, we still maintain that

```
global.console instanceof global.console.Console
```

through a custom Symbol.hasInstance function of Console that tests
for a special symbol kIsConsole for backwards compatibility.

This fixes a case in the console Web Platform Test that we commented
out.

PR-URL: https://github.com/nodejs/node/pull/23509
Refs: https://github.com/whatwg/console/issues/3
Refs: https://console.spec.whatwg.org/#console-namespace
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Denys Otrishko <shishugi@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
Reviewed-By: John-David Dalton <john.david.dalton@gmail.com>

1 files changed, 48 insertions, 31 deletions

diff --git a/test/parallel/test-console-instance.js b/test/parallel/test-console-instance.js
index 0b69212948..87708808a8 100644
--- a/test/parallel/test-console-instance.js
+++ b/test/parallel/test-console-instance.js
@@ -23,7 +23,8 @@
 const common = require('../common');
 const assert = require('assert');
 const Stream = require('stream');
-const Console = require('console').Console;
+const requiredConsole = require('console');
+const Console = requiredConsole.Console;
 
 const out = new Stream();
 const err = new Stream();
@@ -35,6 +36,11 @@ process.stdout.write = process.stderr.write = common.mustNotCall();
 // Make sure that the "Console" function exists.
 assert.strictEqual('function', typeof Console);
 
+assert.strictEqual(requiredConsole, global.console);
+// Make sure the custom instanceof of Console works
+assert.ok(global.console instanceof Console);
+assert.ok(!({} instanceof Console));
+
 // Make sure that the Console constructor throws
 // when not given a writable stream instance.
 common.expectsError(
@@ -62,46 +68,57 @@ common.expectsError(
 
 out.write = err.write = (d) => {};
 
-const c = new Console(out, err);
+{
+  const c = new Console(out, err);
+  assert.ok(c instanceof Console);
 
-out.write = err.write = common.mustCall((d) => {
-  assert.strictEqual(d, 'test\n');
-}, 2);
+  out.write = err.write = common.mustCall((d) => {
+    assert.strictEqual(d, 'test\n');
+  }, 2);
 
-c.log('test');
-c.error('test');
+  c.log('test');
+  c.error('test');
 
-out.write = common.mustCall((d) => {
-  assert.strictEqual(d, '{ foo: 1 }\n');
-});
+  out.write = common.mustCall((d) => {
+    assert.strictEqual(d, '{ foo: 1 }\n');
+  });
 
-c.dir({ foo: 1 });
+  c.dir({ foo: 1 });
 
-// Ensure that the console functions are bound to the console instance.
-let called = 0;
-out.write = common.mustCall((d) => {
-  called++;
-  assert.strictEqual(d, `${called} ${called - 1} [ 1, 2, 3 ]\n`);
-}, 3);
+  // Ensure that the console functions are bound to the console instance.
+  let called = 0;
+  out.write = common.mustCall((d) => {
+    called++;
+    assert.strictEqual(d, `${called} ${called - 1} [ 1, 2, 3 ]\n`);
+  }, 3);
 
-[1, 2, 3].forEach(c.log);
+  [1, 2, 3].forEach(c.log);
+}
 
-// Console() detects if it is called without `new` keyword.
-Console(out, err);
+// Test calling Console without the `new` keyword.
+{
+  const withoutNew = Console(out, err);
+  assert.ok(withoutNew instanceof Console);
+}
 
-// Extending Console works.
-class MyConsole extends Console {
-  hello() {}
+// Test extending Console
+{
+  class MyConsole extends Console {
+    hello() {}
+  }
+  const myConsole = new MyConsole(process.stdout);
+  assert.strictEqual(typeof myConsole.hello, 'function');
+  assert.ok(myConsole instanceof Console);
 }
-const myConsole = new MyConsole(process.stdout);
-assert.strictEqual(typeof myConsole.hello, 'function');
 
 // Instance that does not ignore the stream errors.
-const c2 = new Console(out, err, false);
+{
+  const c2 = new Console(out, err, false);
 
-out.write = () => { throw new Error('out'); };
-err.write = () => { throw new Error('err'); };
+  out.write = () => { throw new Error('out'); };
+  err.write = () => { throw new Error('err'); };
 
-assert.throws(() => c2.log('foo'), /^Error: out$/);
-assert.throws(() => c2.warn('foo'), /^Error: err$/);
-assert.throws(() => c2.dir('foo'), /^Error: out$/);
+  assert.throws(() => c2.log('foo'), /^Error: out$/);
+  assert.throws(() => c2.warn('foo'), /^Error: err$/);
+  assert.throws(() => c2.dir('foo'), /^Error: out$/);
+}