v10.4.0 proposal

CHANGELOG.md

@@ -33,7 +33,8 @@ release.
 </tr>
 <tr>
     <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V10.md#10.3.0">10.3.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V10.md#10.4.0">10.4.0</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V10.md#10.3.0">10.3.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V10.md#10.2.1">10.2.1</a><br/>
 <a href="doc/changelogs/CHANGELOG_V10.md#10.2.0">10.2.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V10.md#10.1.0">10.1.0</a><br/>

Makefile

@@ -643,7 +643,7 @@ available-node = \
 		exit 1; \
 	fi;
 
-run-npm-install = $(PWD)/$(NPM) install --production
+run-npm-install = $(PWD)/$(NPM) install --production --no-package-lock
 
 tools/doc/node_modules/js-yaml/package.json:
 	cd tools/doc && $(call available-node,$(run-npm-install))

benchmark/assert/deepequal-buffer.js

@@ -14,6 +14,8 @@ const bench = common.createBenchmark(main, {
 });
 
 function main({ len, n, method }) {
+  if (!method)
+    method = 'deepEqual';
   const data = Buffer.allocUnsafe(len + 1);
   const actual = Buffer.alloc(len);
   const expected = Buffer.alloc(len);
@@ -22,8 +24,7 @@ function main({ len, n, method }) {
   data.copy(expected);
   data.copy(expectedWrong);
 
-  // eslint-disable-next-line no-restricted-properties
-  const fn = method !== '' ? assert[method] : assert.deepEqual;
+  const fn = assert[method];
   const value2 = method.includes('not') ? expectedWrong : expected;
 
   bench.start();

benchmark/assert/deepequal-map.js

@@ -1,9 +1,8 @@
 'use strict';
 
-/* eslint-disable no-restricted-properties */
-
 const common = require('../common.js');
-const assert = require('assert');
+const { deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
+  require('assert');
 
 const bench = common.createBenchmark(main, {
   n: [5e2],
@@ -47,74 +46,74 @@ function main({ n, len, method }) {
       // Empty string falls through to next line as default, mostly for tests.
     case 'deepEqual_primitiveOnly':
       values = array.map((_, i) => [`str_${i}`, 123]);
-      benchmark(assert.deepEqual, n, values);
+      benchmark(deepEqual, n, values);
       break;
     case 'deepStrictEqual_primitiveOnly':
       values = array.map((_, i) => [`str_${i}`, 123]);
-      benchmark(assert.deepStrictEqual, n, values);
+      benchmark(deepStrictEqual, n, values);
       break;
     case 'deepEqual_objectOnly':
       values = array.map((_, i) => [[`str_${i}`, 1], 123]);
-      benchmark(assert.deepEqual, n, values);
+      benchmark(deepEqual, n, values);
       break;
     case 'deepStrictEqual_objectOnly':
       values = array.map((_, i) => [[`str_${i}`, 1], 123]);
-      benchmark(assert.deepStrictEqual, n, values);
+      benchmark(deepStrictEqual, n, values);
       break;
     case 'deepEqual_mixed':
       values = array.map((_, i) => [i % 2 ? [`str_${i}`, 1] : `str_${i}`, 123]);
-      benchmark(assert.deepEqual, n, values);
+      benchmark(deepEqual, n, values);
       break;
     case 'deepStrictEqual_mixed':
       values = array.map((_, i) => [i % 2 ? [`str_${i}`, 1] : `str_${i}`, 123]);
-      benchmark(assert.deepStrictEqual, n, values);
+      benchmark(deepStrictEqual, n, values);
       break;
     case 'deepEqual_looseMatches':
       values = array.map((_, i) => [i, i]);
       values2 = values.slice().map((v) => [String(v[0]), String(v[1])]);
-      benchmark(assert.deepEqual, n, values, values2);
+      benchmark(deepEqual, n, values, values2);
       break;
     case 'notDeepEqual_primitiveOnly':
       values = array.map((_, i) => [`str_${i}`, 123]);
       values2 = values.slice(0);
       values2[Math.floor(len / 2)] = ['w00t', 123];
-      benchmark(assert.notDeepEqual, n, values, values2);
+      benchmark(notDeepEqual, n, values, values2);
       break;
     case 'notDeepStrictEqual_primitiveOnly':
       values = array.map((_, i) => [`str_${i}`, 123]);
       values2 = values.slice(0);
       values2[Math.floor(len / 2)] = ['w00t', 123];
-      benchmark(assert.notDeepStrictEqual, n, values, values2);
+      benchmark(notDeepStrictEqual, n, values, values2);
       break;
     case 'notDeepEqual_objectOnly':
       values = array.map((_, i) => [[`str_${i}`, 1], 123]);
       values2 = values.slice(0);
       values2[Math.floor(len / 2)] = [['w00t'], 123];
-      benchmark(assert.notDeepEqual, n, values, values2);
+      benchmark(notDeepEqual, n, values, values2);
       break;
     case 'notDeepStrictEqual_objectOnly':
       values = array.map((_, i) => [[`str_${i}`, 1], 123]);
       values2 = values.slice(0);
       values2[Math.floor(len / 2)] = [['w00t'], 123];
-      benchmark(assert.notDeepStrictEqual, n, values, values2);
+      benchmark(notDeepStrictEqual, n, values, values2);
       break;
     case 'notDeepEqual_mixed':
       values = array.map((_, i) => [i % 2 ? [`str_${i}`, 1] : `str_${i}`, 123]);
       values2 = values.slice(0);
       values2[0] = ['w00t', 123];
-      benchmark(assert.notDeepEqual, n, values, values2);
+      benchmark(notDeepEqual, n, values, values2);
       break;
     case 'notDeepStrictEqual_mixed':
       values = array.map((_, i) => [i % 2 ? [`str_${i}`, 1] : `str_${i}`, 123]);
       values2 = values.slice(0);
       values2[0] = ['w00t', 123];
-      benchmark(assert.notDeepStrictEqual, n, values, values2);
+      benchmark(notDeepStrictEqual, n, values, values2);
       break;
     case 'notDeepEqual_looseMatches':
       values = array.map((_, i) => [i, i]);
       values2 = values.slice().map((v) => [String(v[0]), String(v[1])]);
       values2[len - 1] = [String(len + 1), String(len + 1)];
-      benchmark(assert.notDeepEqual, n, values, values2);
+      benchmark(notDeepEqual, n, values, values2);
       break;
     default:
       throw new Error(`Unsupported method ${method}`);

benchmark/assert/deepequal-object.js

@@ -29,13 +29,15 @@ function main({ size, n, method }) {
   // TODO: Fix this "hack". `n` should not be manipulated.
   n = n / size;
 
+  if (!method)
+    method = 'deepEqual';
+
   const source = Array.apply(null, Array(size));
   const actual = createObj(source);
   const expected = createObj(source);
   const expectedWrong = createObj(source, '4');
 
-  // eslint-disable-next-line no-restricted-properties
-  const fn = method !== '' ? assert[method] : assert.deepEqual;
+  const fn = assert[method];
   const value2 = method.includes('not') ? expectedWrong : expected;
 
   bench.start();

benchmark/assert/deepequal-prims-and-objs-big-array-set.js

@@ -1,7 +1,8 @@
 'use strict';
 
 const common = require('../common.js');
-const assert = require('assert');
+const { deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
+  require('assert');
 
 const primValues = {
   'null': null,
@@ -61,32 +62,28 @@ function main({ n, len, primitive, method }) {
     // Empty string falls through to next line as default, mostly for tests.
     case '':
     case 'deepEqual_Array':
-      // eslint-disable-next-line no-restricted-properties
-      run(assert.deepEqual, n, actual, expected);
+      run(deepEqual, n, actual, expected);
       break;
     case 'deepStrictEqual_Array':
-      run(assert.deepStrictEqual, n, actual, expected);
+      run(deepStrictEqual, n, actual, expected);
       break;
     case 'notDeepEqual_Array':
-      // eslint-disable-next-line no-restricted-properties
-      run(assert.notDeepEqual, n, actual, expectedWrong);
+      run(notDeepEqual, n, actual, expectedWrong);
       break;
     case 'notDeepStrictEqual_Array':
-      run(assert.notDeepStrictEqual, n, actual, expectedWrong);
+      run(notDeepStrictEqual, n, actual, expectedWrong);
       break;
     case 'deepEqual_Set':
-      // eslint-disable-next-line no-restricted-properties
-      run(assert.deepEqual, n, actualSet, expectedSet);
+      run(deepEqual, n, actualSet, expectedSet);
       break;
     case 'deepStrictEqual_Set':
-      run(assert.deepStrictEqual, n, actualSet, expectedSet);
+      run(deepStrictEqual, n, actualSet, expectedSet);
       break;
     case 'notDeepEqual_Set':
-      // eslint-disable-next-line no-restricted-properties
-      run(assert.notDeepEqual, n, actualSet, expectedWrongSet);
+      run(notDeepEqual, n, actualSet, expectedWrongSet);
       break;
     case 'notDeepStrictEqual_Set':
-      run(assert.notDeepStrictEqual, n, actualSet, expectedWrongSet);
+      run(notDeepStrictEqual, n, actualSet, expectedWrongSet);
       break;
     default:
       throw new Error(`Unsupported method "${method}"`);

benchmark/assert/deepequal-prims-and-objs-big-loop.js

@@ -25,13 +25,14 @@ const bench = common.createBenchmark(main, {
 });
 
 function main({ n, primitive, method }) {
+  if (!method)
+    method = 'deepEqual';
   const prim = primValues[primitive];
   const actual = prim;
   const expected = prim;
   const expectedWrong = 'b';
 
-  // eslint-disable-next-line no-restricted-properties
-  const fn = method !== '' ? assert[method] : assert.deepEqual;
+  const fn = assert[method];
   const value2 = method.includes('not') ? expectedWrong : expected;
 
   bench.start();

benchmark/assert/deepequal-set.js

@@ -1,9 +1,8 @@
 'use strict';
 
-/* eslint-disable no-restricted-properties */
-
 const common = require('../common.js');
-const assert = require('assert');
+const { deepEqual, deepStrictEqual, notDeepEqual, notDeepStrictEqual } =
+  require('assert');
 
 const bench = common.createBenchmark(main, {
   n: [5e2],
@@ -48,82 +47,82 @@ function main({ n, len, method }) {
       // Empty string falls through to next line as default, mostly for tests.
     case 'deepEqual_primitiveOnly':
       values = array.map((_, i) => `str_${i}`);
-      benchmark(assert.deepEqual, n, values);
+      benchmark(deepEqual, n, values);
       break;
     case 'deepStrictEqual_primitiveOnly':
       values = array.map((_, i) => `str_${i}`);
-      benchmark(assert.deepStrictEqual, n, values);
+      benchmark(deepStrictEqual, n, values);
       break;
     case 'deepEqual_objectOnly':
       values = array.map((_, i) => [`str_${i}`, null]);
-      benchmark(assert.deepEqual, n, values);
+      benchmark(deepEqual, n, values);
       break;
     case 'deepStrictEqual_objectOnly':
       values = array.map((_, i) => [`str_${i}`, null]);
-      benchmark(assert.deepStrictEqual, n, values);
+      benchmark(deepStrictEqual, n, values);
       break;
     case 'deepEqual_mixed':
       values = array.map((_, i) => {
         return i % 2 ? [`str_${i}`, null] : `str_${i}`;
       });
-      benchmark(assert.deepEqual, n, values);
+      benchmark(deepEqual, n, values);
       break;
     case 'deepStrictEqual_mixed':
       values = array.map((_, i) => {
         return i % 2 ? [`str_${i}`, null] : `str_${i}`;
       });
-      benchmark(assert.deepStrictEqual, n, values);
+      benchmark(deepStrictEqual, n, values);
       break;
     case 'deepEqual_looseMatches':
       values = array.map((_, i) => i);
       values2 = values.slice().map((v) => String(v));
-      benchmark(assert.deepEqual, n, values, values2);
+      benchmark(deepEqual, n, values, values2);
       break;
     case 'notDeepEqual_primitiveOnly':
       values = array.map((_, i) => `str_${i}`);
       values2 = values.slice(0);
       values2[Math.floor(len / 2)] = 'w00t';
-      benchmark(assert.notDeepEqual, n, values, values2);
+      benchmark(notDeepEqual, n, values, values2);
       break;
     case 'notDeepStrictEqual_primitiveOnly':
       values = array.map((_, i) => `str_${i}`);
       values2 = values.slice(0);
       values2[Math.floor(len / 2)] = 'w00t';
-      benchmark(assert.notDeepStrictEqual, n, values, values2);
+      benchmark(notDeepStrictEqual, n, values, values2);
       break;
     case 'notDeepEqual_objectOnly':
       values = array.map((_, i) => [`str_${i}`, null]);
       values2 = values.slice(0);
       values2[Math.floor(len / 2)] = ['w00t'];
-      benchmark(assert.notDeepEqual, n, values, values2);
+      benchmark(notDeepEqual, n, values, values2);
       break;
     case 'notDeepStrictEqual_objectOnly':
       values = array.map((_, i) => [`str_${i}`, null]);
       values2 = values.slice(0);
       values2[Math.floor(len / 2)] = ['w00t'];
-      benchmark(assert.notDeepStrictEqual, n, values, values2);
+      benchmark(notDeepStrictEqual, n, values, values2);
       break;
     case 'notDeepEqual_mixed':
       values = array.map((_, i) => {
         return i % 2 ? [`str_${i}`, null] : `str_${i}`;
       });
       values2 = values.slice();
       values2[0] = 'w00t';
-      benchmark(assert.notDeepEqual, n, values, values2);
+      benchmark(notDeepEqual, n, values, values2);
       break;
     case 'notDeepStrictEqual_mixed':
       values = array.map((_, i) => {
         return i % 2 ? [`str_${i}`, null] : `str_${i}`;
       });
       values2 = values.slice();
       values2[0] = 'w00t';
-      benchmark(assert.notDeepStrictEqual, n, values, values2);
+      benchmark(notDeepStrictEqual, n, values, values2);
       break;
     case 'notDeepEqual_looseMatches':
       values = array.map((_, i) => i);
       values2 = values.slice().map((v) => String(v));
       values2[len - 1] = String(len + 1);
-      benchmark(assert.notDeepEqual, n, values, values2);
+      benchmark(notDeepEqual, n, values, values2);
       break;
     default:
       throw new Error(`Unsupported method "${method}"`);

benchmark/assert/deepequal-typedarrays.js

@@ -25,15 +25,16 @@ const bench = common.createBenchmark(main, {
 });
 
 function main({ type, n, len, method }) {
+  if (!method)
+    method = 'deepEqual';
   const clazz = global[type];
   const actual = new clazz(len);
   const expected = new clazz(len);
   const expectedWrong = Buffer.alloc(len);
   const wrongIndex = Math.floor(len / 2);
   expectedWrong[wrongIndex] = 123;
 
-  // eslint-disable-next-line no-restricted-properties
-  const fn = method !== '' ? assert[method] : assert.deepEqual;
+  const fn = assert[method];
   const value2 = method.includes('not') ? expectedWrong : expected;
 
   bench.start();