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

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,
+  SharedArrayBuffer,
+  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);
+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(SharedArrayBuffer);
+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,20 @@ 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)) {
+      if (val1.constructor !== val2.constructor) {
+        return false;
+      }
+    } else if (hasOwn(val1, 'constructor')) {
+      if (ObjectGetPrototypeOf(val1) !== ObjectGetPrototypeOf(val2)) {
+        return false;
+      }
+    } else if ((val1.constructor !== val2.constructor ||
+               (val1.constructor === undefined &&
+                 ObjectGetPrototypeOf(val1) !== ObjectGetPrototypeOf(val2)))) {
+      return false;
+    }
   }
 
   const val1Tag = ObjectPrototypeToString(val1);

test/parallel/test-assert-deep.js

@@ -1527,46 +1527,63 @@ 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);
-}
+    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/
+      }
+    );
+  }
+});
 
-{
-  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;
+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://bar');
-  assert.throws(
-    () => assert.deepStrictEqual(a, b),
-    {
-      code: 'ERR_ASSERTION',
-      name: 'AssertionError',
-      message: /http:\/\/bar/
-    }
-  );
-}
+  const prototype = {};
+  Object.setPrototypeOf(a, prototype);
+  Object.setPrototypeOf(b, prototype);
+  assertDeepAndStrictEqual(a, b);
+
+  Object.setPrototypeOf(b, {});
+  assertNotDeepOrStrict(a, {});
+});