[v11.x] backport #25087, #24962, #24931 and #25006

doc/api/util.md

@@ -375,6 +375,9 @@ stream.write('With ES6');
 <!-- YAML
 added: v0.3.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/25006
+    description: ArrayBuffers now also show their binary contents.
   - version: v11.5.0
     pr-url: https://github.com/nodejs/node/pull/24852
     description: The `getters` option is supported now.

lib/buffer.js

@@ -48,9 +48,7 @@ const {
   isArrayBufferView,
   isUint8Array
 } = require('internal/util/types');
-const {
-  pendingDeprecation
-} = internalBinding('config');
+
 const {
   ERR_BUFFER_OUT_OF_BOUNDS,
   ERR_OUT_OF_RANGE,
@@ -138,7 +136,7 @@ const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
 function showFlaggedDeprecation() {
   if (bufferWarningAlreadyEmitted ||
       ++nodeModulesCheckCounter > 10000 ||
-      (!pendingDeprecation &&
+      (!require('internal/options').getOptionValue('--pending-deprecation') &&
        isInsideNodeModules())) {
     // We don't emit a warning, because we either:
     // - Already did so, or

lib/inspector.js

@@ -11,7 +11,7 @@ const {
 } = require('internal/errors').codes;
 const { validateString } = require('internal/validators');
 const util = require('util');
-const { Connection, open, url } = process.binding('inspector');
+const { Connection, open, url } = internalBinding('inspector');
 const { originalConsole } = require('internal/process/per_thread');
 
 if (!Connection)

lib/internal/bootstrap/loaders.js

@@ -85,8 +85,10 @@
     'fs_event_wrap',
     'http_parser',
     'icu',
+    'inspector',
     'js_stream',
     'natives',
+    'os',
     'pipe_wrap',
     'process_wrap',
     'signal_wrap',

lib/internal/bootstrap/node.js

@@ -177,7 +177,7 @@
     {
       // Install legacy getters on the `util` binding for typechecking.
       // TODO(addaleax): Turn into a full runtime deprecation.
-      const { pendingDeprecation } = internalBinding('config');
+      const pendingDeprecation = getOptionValue('--pending-deprecation');
       const utilBinding = internalBinding('util');
       const types = internalBinding('types');
       for (const name of [

lib/internal/inspector_async_hook.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const inspector = process.binding('inspector');
+const inspector = internalBinding('inspector');
 
 if (!inspector || !inspector.asyncTaskScheduled) {
   exports.setup = function() {};

lib/internal/modules/cjs/helpers.js

@@ -108,7 +108,7 @@ if (getOptionValue('--experimental-worker')) {
   builtinLibs.sort();
 }
 
-if (typeof process.binding('inspector').open === 'function') {
+if (typeof internalBinding('inspector').open === 'function') {
   builtinLibs.push('inspector');
   builtinLibs.sort();
 }

lib/internal/modules/cjs/loader.js

@@ -706,7 +706,7 @@ Module.prototype._compile = function(content, filename) {
     // Set breakpoint on module start
     if (filename === resolvedArgv) {
       delete process._breakFirstLine;
-      inspectorWrapper = process.binding('inspector').callAndPauseOnStart;
+      inspectorWrapper = internalBinding('inspector').callAndPauseOnStart;
     }
   }
   var dirname = path.dirname(filename);

lib/internal/modules/esm/module_job.js

@@ -73,7 +73,7 @@ class ModuleJob {
     try {
       if (this.isMain && process._breakFirstLine) {
         delete process._breakFirstLine;
-        const initWrapper = process.binding('inspector').callAndPauseOnStart;
+        const initWrapper = internalBinding('inspector').callAndPauseOnStart;
         initWrapper(this.module.instantiate, this.module);
       } else {
         this.module.instantiate();

lib/internal/process/coverage.js

@@ -51,7 +51,7 @@ function disableAllAsyncHooks() {
 exports.writeCoverage = writeCoverage;
 
 function setup() {
-  const { Connection } = process.binding('inspector');
+  const { Connection } = internalBinding('inspector');
   if (!Connection) {
     console.warn('inspector not enabled');
     return;

lib/internal/util/inspect.js

@@ -89,6 +89,7 @@ const setValues = uncurryThis(Set.prototype.values);
 const mapEntries = uncurryThis(Map.prototype.entries);
 const dateGetTime = uncurryThis(Date.prototype.getTime);
 const hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+let hexSlice;
 
 const inspectDefaultOptions = Object.seal({
   showHidden: false,
@@ -494,7 +495,7 @@ function noPrototypeIterator(ctx, value, recurseTimes) {
 // Note: using `formatValue` directly requires the indentation level to be
 // corrected by setting `ctx.indentationLvL += diff` and then to decrease the
 // value afterwards again.
-function formatValue(ctx, value, recurseTimes) {
+function formatValue(ctx, value, recurseTimes, typedArray) {
   // Primitive types cannot have properties.
   if (typeof value !== 'object' && typeof value !== 'function') {
     return formatPrimitive(ctx.stylize, value, ctx);
@@ -542,10 +543,10 @@ function formatValue(ctx, value, recurseTimes) {
   if (ctx.seen.indexOf(value) !== -1)
     return ctx.stylize('[Circular]', 'special');
 
-  return formatRaw(ctx, value, recurseTimes);
+  return formatRaw(ctx, value, recurseTimes, typedArray);
 }
 
-function formatRaw(ctx, value, recurseTimes) {
+function formatRaw(ctx, value, recurseTimes, typedArray) {
   let keys;
 
   const constructor = getConstructorName(value, ctx);
@@ -678,9 +679,12 @@ function formatRaw(ctx, value, recurseTimes) {
       const arrayType = isArrayBuffer(value) ? 'ArrayBuffer' :
         'SharedArrayBuffer';
       const prefix = getPrefix(constructor, tag, arrayType);
-      if (keys.length === 0)
+      if (typedArray === undefined) {
+        formatter = formatArrayBuffer;
+      } else if (keys.length === 0) {
         return prefix +
               `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength)} }`;
+      }
       braces[0] = `${prefix}{`;
       keys.unshift('byteLength');
     } else if (isDataView(value)) {
@@ -941,6 +945,18 @@ function formatSpecialArray(ctx, value, recurseTimes, maxLength, output, i) {
   return output;
 }
 
+function formatArrayBuffer(ctx, value) {
+  const buffer = new Uint8Array(value);
+  if (hexSlice === undefined)
+    hexSlice = uncurryThis(require('buffer').Buffer.prototype.hexSlice);
+  let str = hexSlice(buffer, 0, Math.min(ctx.maxArrayLength, buffer.length))
+    .replace(/(.{2})/g, '$1 ').trim();
+  const remaining = buffer.length - ctx.maxArrayLength;
+  if (remaining > 0)
+    str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+  return [`${ctx.stylize('[Uint8Contents]', 'special')}: <${str}>`];
+}
+
 function formatArray(ctx, value, recurseTimes) {
   const valLen = value.length;
   const len = Math.min(Math.max(0, ctx.maxArrayLength), valLen);
@@ -981,7 +997,7 @@ function formatTypedArray(ctx, value, recurseTimes) {
       'byteOffset',
       'buffer'
     ]) {
-      const str = formatValue(ctx, value[key], recurseTimes);
+      const str = formatValue(ctx, value[key], recurseTimes, true);
       output.push(`[${key}]: ${str}`);
     }
     ctx.indentationLvl -= 2;

lib/os.js

@@ -44,7 +44,7 @@ const {
   getUptime,
   isBigEndian,
   setPriority: _setPriority
-} = process.binding('os');
+} = internalBinding('os');
 
 function getCheckedFunction(fn) {
   return function checkError(...args) {

src/inspector_js_api.cc

@@ -315,5 +315,5 @@ void Initialize(Local<Object> target, Local<Value> unused,
 }  // namespace inspector
 }  // namespace node
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(inspector,
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(inspector,
                                   node::inspector::Initialize);

src/node.cc

@@ -2238,5 +2238,5 @@ int Start(int argc, char** argv) {
 #if !HAVE_INSPECTOR
 void Initialize() {}
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(inspector, Initialize)
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(inspector, Initialize)
 #endif  // !HAVE_INSPECTOR

src/node_config.cc

@@ -77,9 +77,6 @@ static void Initialize(Local<Object> target,
   if (env->options()->experimental_repl_await)
     READONLY_TRUE_PROPERTY(target, "experimentalREPLAwait");
 
-  if (env->options()->pending_deprecation)
-    READONLY_TRUE_PROPERTY(target, "pendingDeprecation");
-
   if (env->options()->expose_internals)
     READONLY_TRUE_PROPERTY(target, "exposeInternals");
 

src/node_os.cc

@@ -467,4 +467,4 @@ void Initialize(Local<Object> target,
 }  // namespace os
 }  // namespace node
 
-NODE_BUILTIN_MODULE_CONTEXT_AWARE(os, node::os::Initialize)
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(os, node::os::Initialize)

test/parallel/test-os-checked-function.js

@@ -1,7 +1,11 @@
 'use strict';
+// Flags: --expose_internals
+
+const { internalBinding } = require('internal/test/binding');
+
 // Monkey patch the os binding before requiring any other modules, including
 // common, which requires the os module.
-process.binding('os').getHomeDirectory = function(ctx) {
+internalBinding('os').getHomeDirectory = function(ctx) {
   ctx.syscall = 'foo';
   ctx.code = 'bar';
   ctx.message = 'baz';

test/parallel/test-pending-deprecation.js

@@ -1,44 +1,53 @@
 'use strict';
 
-// Tests that --pending-deprecation and NODE_PENDING_DEPRECATION both
-// set the process.binding('config').pendingDeprecation flag that is
-// used to determine if pending deprecation messages should be shown.
-// The test is performed by launching two child processes that run
+// Flags: --expose-internals
+// Tests that --pending-deprecation and NODE_PENDING_DEPRECATION both set the
+// `require('internal/options').getOptionValue('--pending-deprecation')`
+// flag that is used to determine if pending deprecation messages should be
+// shown. The test is performed by launching two child processes that run
 // this same test script with different arguments. If those exit with
 // code 0, then the test passes. If they don't, it fails.
 
+// TODO(joyeecheung): instead of testing internals, test the actual features
+// pending deprecations.
+
 const common = require('../common');
 
 const assert = require('assert');
-const config = process.binding('config');
 const fork = require('child_process').fork;
+const { getOptionValue } = require('internal/options');
 
 function message(name) {
-  return `${name} did not set the process.binding('config').` +
-         'pendingDeprecation flag.';
+  return `${name} did not affect getOptionValue('--pending-deprecation')`;
 }
 
 switch (process.argv[2]) {
   case 'env':
   case 'switch':
-    assert.strictEqual(config.pendingDeprecation, true);
+    assert.strictEqual(
+      getOptionValue('--pending-deprecation'),
+      true
+    );
     break;
   default:
     // Verify that the flag is off by default.
     const envvar = process.env.NODE_PENDING_DEPRECATION;
-    assert.strictEqual(config.pendingDeprecation, envvar && envvar[0] === '1');
+    assert.strictEqual(
+      getOptionValue('--pending-deprecation'),
+      !!(envvar && envvar[0] === '1')
+    );
 
     // Test the --pending-deprecation command line switch.
     fork(__filename, ['switch'], {
-      execArgv: ['--pending-deprecation'],
+      execArgv: ['--pending-deprecation', '--expose-internals'],
       silent: true
     }).on('exit', common.mustCall((code) => {
       assert.strictEqual(code, 0, message('--pending-deprecation'));
     }));
 
     // Test the --pending_deprecation command line switch.
     fork(__filename, ['switch'], {
-      execArgv: ['--pending_deprecation'],
+      execArgv: ['--pending_deprecation', '--expose-internals'],
       silent: true
     }).on('exit', common.mustCall((code) => {
       assert.strictEqual(code, 0, message('--pending_deprecation'));
@@ -47,6 +56,7 @@ switch (process.argv[2]) {
     // Test the NODE_PENDING_DEPRECATION environment var.
     fork(__filename, ['env'], {
       env: Object.assign({}, process.env, { NODE_PENDING_DEPRECATION: 1 }),
+      execArgv: ['--expose-internals'],
       silent: true
     }).on('exit', common.mustCall((code) => {
       assert.strictEqual(code, 0, message('NODE_PENDING_DEPRECATION'));

test/parallel/test-process-binding-internalbinding-whitelist.js

@@ -16,3 +16,5 @@ assert(process.binding('url'));
 assert(process.binding('spawn_sync'));
 assert(process.binding('js_stream'));
 assert(process.binding('buffer'));
+assert(process.binding('inspector'));
+assert(process.binding('os'));

test/parallel/test-util-format.js

@@ -308,3 +308,8 @@ Object.setPrototypeOf(BadCustomError.prototype, Error.prototype);
 Object.setPrototypeOf(BadCustomError, Error);
 assert.strictEqual(util.format(new BadCustomError('foo')),
                    '[BadCustomError: foo]');
+
+assert.strictEqual(
+  util.format(new SharedArrayBuffer(4)),
+  'SharedArrayBuffer { [Uint8Contents]: <00 00 00 00>, byteLength: 4 }'
+);