assert,util: fix constructor lookup in deep equal comparison

The latest performance optimization did not take into account that
an object may have a property called constructor. This is addressed
in this PR by adding a new fast path and using fallbacks.

Author: BridgeAR

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

@@ -10,6 +10,7 @@ const notCircular = {};
 notCircular.circular = {};
 
 const primValues = {
+  'null_prototype': { __proto__: null },
   'string': 'abcdef',
   'number': 1_000,
   'boolean': true,
@@ -24,6 +25,7 @@ const primValues = {
 };
 
 const primValues2 = {
+  'null_prototype': { __proto__: null },
   'object': { property: 'abcdef' },
   'array': [1, 2, 3],
   'set_object': new Set([[1]]),
@@ -35,6 +37,7 @@ const primValues2 = {
 };
 
 const primValuesUnequal = {
+  'null_prototype': { __proto__: { __proto__: null } },
   'string': 'abcdez',
   'number': 1_001,
   'boolean': false,

lib/internal/util/comparisons.js

@@ -1,14 +1,32 @@
 'use strict';
 
 const {
+  Array,
+  ArrayBuffer,
   ArrayIsArray,
   ArrayPrototypeFilter,
   ArrayPrototypePush,
+  BigInt,
+  BigInt64Array,
   BigIntPrototypeValueOf,
+  BigUint64Array,
+  Boolean,
   BooleanPrototypeValueOf,
+  DataView,
+  Date,
   DatePrototypeGetTime,
   Error,
+  Float16Array,
+  Float32Array,
+  Float64Array,
+  Function,
+  Int16Array,
+  Int32Array,
+  Int8Array,
+  Map,
+  Number,
   NumberPrototypeValueOf,
+  Object,
   ObjectGetOwnPropertyDescriptor,
   ObjectGetOwnPropertySymbols: getOwnSymbols,
   ObjectGetPrototypeOf,
@@ -17,18 +35,65 @@ const {
   ObjectPrototypeHasOwnProperty: hasOwn,
   ObjectPrototypePropertyIsEnumerable: hasEnumerable,
   ObjectPrototypeToString,
+  Promise,
+  RegExp,
   SafeSet,
+  Set,
+  String,
   StringPrototypeValueOf,
+  Symbol,
   SymbolPrototypeValueOf,
   TypedArrayPrototypeGetByteLength: getByteLength,
   TypedArrayPrototypeGetSymbolToStringTag,
+  Uint16Array,
+  Uint32Array,
   Uint8Array,
+  Uint8ClampedArray,
+  WeakMap,
+  WeakSet,
 } = primordials;
 
 const { compare } = internalBinding('buffer');
 const assert = require('internal/assert');
 const { isURL } = require('internal/url');
 const { isError } = require('internal/util');
+const { Buffer } = require('buffer');
+
+const wellKnownConstructors = new SafeSet();
+wellKnownConstructors.add(Array);
+wellKnownConstructors.add(ArrayBuffer);
+wellKnownConstructors.add(BigInt);
+wellKnownConstructors.add(BigInt64Array);
+wellKnownConstructors.add(BigUint64Array);
+wellKnownConstructors.add(Boolean);
+wellKnownConstructors.add(Buffer);
+wellKnownConstructors.add(DataView);
+wellKnownConstructors.add(Date);
+wellKnownConstructors.add(Error);
+if (Float16Array) { // TODO(BridgeAR): Remove when regularly supported
+  wellKnownConstructors.add(Float16Array);
+}
+wellKnownConstructors.add(Float32Array);
+wellKnownConstructors.add(Float64Array);
+wellKnownConstructors.add(Function);
+wellKnownConstructors.add(Int16Array);
+wellKnownConstructors.add(Int32Array);
+wellKnownConstructors.add(Int8Array);
+wellKnownConstructors.add(Map);
+wellKnownConstructors.add(Number);
+wellKnownConstructors.add(Object);
+wellKnownConstructors.add(Promise);
+wellKnownConstructors.add(RegExp);
+wellKnownConstructors.add(Set);
+wellKnownConstructors.add(String);
+wellKnownConstructors.add(Symbol);
+wellKnownConstructors.add(Uint16Array);
+wellKnownConstructors.add(Uint32Array);
+wellKnownConstructors.add(Uint8Array);
+wellKnownConstructors.add(Uint8ClampedArray);
+wellKnownConstructors.add(WeakMap);
+wellKnownConstructors.add(WeakSet);
+
 const types = require('internal/util/types');
 const {
   isAnyArrayBuffer,
@@ -198,11 +263,15 @@ function innerDeepEqual(val1, val2, mode, memos) {
 }
 
 function objectComparisonStart(val1, val2, mode, memos) {
-  if (mode === kStrict &&
-      (val1.constructor !== val2.constructor ||
-        (val1.constructor === undefined &&
-          ObjectGetPrototypeOf(val1) !== ObjectGetPrototypeOf(val2)))) {
-    return false;
+  if (mode === kStrict) {
+    if (wellKnownConstructors.has(val1.constructor) ||
+        (val1.constructor !== undefined && !hasOwn(val1, 'constructor'))) {
+      if (val1.constructor !== val2.constructor) {
+        return false;
+      }
+    } else if (ObjectGetPrototypeOf(val1) !== ObjectGetPrototypeOf(val2)) {
+      return false;
+    }
   }
 
   const val1Tag = ObjectPrototypeToString(val1);

test/parallel/test-assert-deep.js

@@ -1527,46 +1527,107 @@ test('Detects differences in deeply nested arrays instead of seeing a new object
   );
 });
 
-// check URL
-{
-  const a = new URL('http://foo');
-  const b = new URL('http://bar');
+test('URLs', () => {
+  // check URL
+  {
+    const a = new URL('http://foo');
+    const b = new URL('http://bar');
 
-  assertNotDeepOrStrict(a, b);
-}
+    assertNotDeepOrStrict(a, b);
+  }
 
-{
-  const a = new URL('http://foo');
-  const b = new URL('http://foo');
+  {
+    const a = new URL('http://foo');
+    const b = new URL('http://foo');
 
+    assertDeepAndStrictEqual(a, b);
+  }
+
+  {
+    const a = new URL('http://foo');
+    const b = new URL('http://foo');
+    a.bar = 1;
+    b.bar = 2;
+    assertNotDeepOrStrict(a, b);
+  }
+
+  {
+    const a = new URL('http://foo');
+    const b = new URL('http://foo');
+    a.bar = 1;
+    b.bar = 1;
+    assertDeepAndStrictEqual(a, b);
+  }
+
+  {
+    const a = new URL('http://foo');
+    const b = new URL('http://bar');
+    assert.throws(
+      () => assert.deepStrictEqual(a, b),
+      {
+        code: 'ERR_ASSERTION',
+        name: 'AssertionError',
+        message: /http:\/\/bar/
+      }
+    );
+  }
+});
+
+test('Own property constructor properties should check against the original prototype', () => {
+  const a = { constructor: { name: 'Foo' } };
+  const b = { constructor: { name: 'Foo' } };
   assertDeepAndStrictEqual(a, b);
-}
 
-{
-  const a = new URL('http://foo');
-  const b = new URL('http://foo');
-  a.bar = 1;
-  b.bar = 2;
-  assertNotDeepOrStrict(a, b);
-}
+  let prototype = {};
+  Object.setPrototypeOf(a, prototype);
+  Object.setPrototypeOf(b, prototype);
+  assertDeepAndStrictEqual(a, b);
 
-{
-  const a = new URL('http://foo');
-  const b = new URL('http://foo');
-  a.bar = 1;
-  b.bar = 1;
+  Object.setPrototypeOf(b, {});
+  assertNotDeepOrStrict(a, {});
+
+  prototype = { __proto__: null };
+  Object.setPrototypeOf(a, prototype);
+  Object.setPrototypeOf(b, prototype);
   assertDeepAndStrictEqual(a, b);
-}
 
-{
-  const a = new URL('http://foo');
-  const b = new URL('http://bar');
-  assert.throws(
-    () => assert.deepStrictEqual(a, b),
-    {
-      code: 'ERR_ASSERTION',
-      name: 'AssertionError',
-      message: /http:\/\/bar/
-    }
-  );
-}
+  Object.setPrototypeOf(b, { __proto__: null });
+  assert.notDeepStrictEqual(a, b);
+  assert.notDeepStrictEqual(b, a);
+
+  // Turn off no-restricted-properties because we are testing deepEqual!
+  /* eslint-disable no-restricted-properties */
+  assert.deepEqual(a, b);
+  assert.deepEqual(b, a);
+});
+
+test('Inherited null prototype without own constructor properties should check the correct prototype', () => {
+  const a = { foo: { name: 'Foo' } };
+  const b = { foo: { name: 'Foo' } };
+  assertDeepAndStrictEqual(a, b);
+
+  let prototype = {};
+  Object.setPrototypeOf(a, prototype);
+  Object.setPrototypeOf(b, prototype);
+  assertDeepAndStrictEqual(a, b);
+
+  Object.setPrototypeOf(b, {});
+  assertNotDeepOrStrict(a, {});
+
+  prototype = { __proto__: null };
+  Object.setPrototypeOf(a, prototype);
+  Object.setPrototypeOf(b, prototype);
+  assertDeepAndStrictEqual(a, b);
+
+  Object.setPrototypeOf(b, { __proto__: null });
+  assert.notDeepStrictEqual(a, b);
+  assert.notDeepStrictEqual(b, a);
+
+  assert.notDeepStrictEqual({ __proto__: null }, { __proto__: { __proto__: null } });
+  assert.notDeepStrictEqual({ __proto__: { __proto__: null } }, { __proto__: null });
+
+  // Turn off no-restricted-properties because we are testing deepEqual!
+  /* eslint-disable no-restricted-properties */
+  assert.deepEqual(a, b);
+  assert.deepEqual(b, a);
+});