assert,util: improve deep equal comparison performance

This allows the compiler to inline parts of the code in a way that
especially primitives in arrays can be compared faster.

Author: BridgeAR

lib/internal/util/comparisons.js

@@ -164,18 +164,6 @@ function isEnumerableOrIdentical(val1, val2, prop, mode, memos, method) {
       innerDeepEqual(val1[prop], val2[prop], mode, memos);
 }
 
-// Notes: Type tags are historical [[Class]] properties that can be set by
-// FunctionTemplate::SetClassName() in C++ or Symbol.toStringTag in JS
-// and retrieved using Object.prototype.toString.call(obj) in JS
-// See https://tc39.github.io/ecma262/#sec-object.prototype.tostring
-// for a list of tags pre-defined in the spec.
-// There are some unspecified tags in the wild too (e.g. typed array tags).
-// Since tags can be altered, they only serve fast failures
-//
-// For strict comparison, objects should have
-// a) The same built-in type tag.
-// b) The same prototypes.
-
 function innerDeepEqual(val1, val2, mode, memos) {
   // All identical values are equivalent, as determined by ===.
   if (val1 === val2) {
@@ -192,11 +180,7 @@ function innerDeepEqual(val1, val2, mode, memos) {
     if (typeof val2 !== 'object' ||
         typeof val1 !== 'object' ||
         val1 === null ||
-        val2 === null ||
-        (mode === kStrict &&
-          (val1.constructor !== val2.constructor ||
-            (val1.constructor === undefined &&
-              ObjectGetPrototypeOf(val1) !== ObjectGetPrototypeOf(val2))))) {
+        val2 === null) {
       return false;
     }
   } else {
@@ -210,6 +194,17 @@ function innerDeepEqual(val1, val2, mode, memos) {
       return false;
     }
   }
+  return objectComparisonStart(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;
+  }
+
   const val1Tag = ObjectPrototypeToString(val1);
   const val2Tag = ObjectPrototypeToString(val2);
 
@@ -218,7 +213,6 @@ function innerDeepEqual(val1, val2, mode, memos) {
   }
 
   if (ArrayIsArray(val1)) {
-    // Check for sparse arrays and general fast path
     if (!ArrayIsArray(val2) ||
         (val1.length !== val2.length && (mode !== kPartial || val1.length < val2.length))) {
       return false;
@@ -473,9 +467,9 @@ function keyCheck(val1, val2, mode, memos, iterationType, keys2) {
   return areEq;
 }
 
-function setHasEqualElement(set, val1, mode, memo) {
+function setHasEqualElement(set, val1, mode, memo, fn) {
   for (const val2 of set) {
-    if (innerDeepEqual(val1, val2, mode, memo)) {
+    if (fn(val1, val2, mode, memo)) {
       // Remove the matching element to make sure we do not check that again.
       set.delete(val2);
       return true;
@@ -537,7 +531,7 @@ function partialObjectSetEquiv(a, b, mode, set, memo) {
   let aPos = 0;
   for (const val of a) {
     aPos++;
-    if (!b.has(val) && setHasEqualElement(set, val, mode, memo) && set.size === 0) {
+    if (!b.has(val) && setHasEqualElement(set, val, mode, memo, innerDeepEqual) && set.size === 0) {
       return true;
     }
     if (a.size - aPos < set.size) {
@@ -552,7 +546,7 @@ function setObjectEquiv(a, b, mode, set, memo) {
   // Fast path for objects only
   if (mode !== kLoose && set.size === a.size) {
     for (const val of a) {
-      if (!setHasEqualElement(set, val, mode, memo)) {
+      if (!setHasEqualElement(set, val, mode, memo, objectComparisonStart)) {
         return false;
       }
     }
@@ -562,15 +556,16 @@ function setObjectEquiv(a, b, mode, set, memo) {
     return partialObjectSetEquiv(a, b, mode, set, memo);
   }
 
+  const fn = mode === kStrict ? objectComparisonStart : innerDeepEqual;
   for (const val of a) {
     // Primitive values have already been handled above.
     if (typeof val === 'object') {
-      if (!b.has(val) && !setHasEqualElement(set, val, mode, memo)) {
+      if (!b.has(val) && !setHasEqualElement(set, val, mode, memo, fn)) {
         return false;
       }
     } else if (mode === kLoose &&
               !b.has(val) &&
-              !setHasEqualElement(set, val, mode, memo)) {
+              !setHasEqualElement(set, val, mode, memo, innerDeepEqual)) {
       return false;
     }
   }
@@ -626,12 +621,12 @@ function setEquiv(a, b, mode, memo) {
   return true;
 }
 
-function mapHasEqualEntry(set, map, key1, item1, mode, memo) {
+function mapHasEqualEntry(set, map, key1, item1, mode, memo, fn) {
   // To be able to handle cases like:
   //   Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']])
   // ... we need to consider *all* matching keys, not just the first we find.
   for (const key2 of set) {
-    if (innerDeepEqual(key1, key2, mode, memo) &&
+    if (fn(key1, key2, mode, memo) &&
       innerDeepEqual(item1, map.get(key2), mode, memo)) {
       set.delete(key2);
       return true;
@@ -647,7 +642,7 @@ function partialObjectMapEquiv(a, b, mode, set, memo) {
     aPos++;
     if (typeof key1 === 'object' &&
         key1 !== null &&
-        mapHasEqualEntry(set, b, key1, item1, mode, memo) &&
+        mapHasEqualEntry(set, b, key1, item1, mode, memo, objectComparisonStart) &&
         set.size === 0) {
       return true;
     }
@@ -663,7 +658,7 @@ function mapObjectEquivalence(a, b, mode, set, memo) {
   // Fast path for objects only
   if (mode !== kLoose && set.size === a.size) {
     for (const { 0: key1, 1: item1 } of a) {
-      if (!mapHasEqualEntry(set, b, key1, item1, mode, memo)) {
+      if (!mapHasEqualEntry(set, b, key1, item1, mode, memo, objectComparisonStart)) {
         return false;
       }
     }
@@ -672,16 +667,17 @@ function mapObjectEquivalence(a, b, mode, set, memo) {
   if (mode === kPartial) {
     return partialObjectMapEquiv(a, b, mode, set, memo);
   }
+  const fn = mode === kStrict ? objectComparisonStart : innerDeepEqual;
   for (const { 0: key1, 1: item1 } of a) {
     if (typeof key1 === 'object' && key1 !== null) {
-      if (!mapHasEqualEntry(set, b, key1, item1, mode, memo))
+      if (!mapHasEqualEntry(set, b, key1, item1, mode, memo, fn))
         return false;
     } else if (set.size === 0) {
       return true;
     } else if (mode === kLoose &&
               (!b.has(key1) ||
                 !innerDeepEqual(item1, b.get(key1), mode, memo)) &&
-              !mapHasEqualEntry(set, b, key1, item1, mode, memo)) {
+              !mapHasEqualEntry(set, b, key1, item1, mode, memo, innerDeepEqual)) {
       return false;
     }
   }