assert: refactor to use more primordials

Author: aduh95

lib/assert.js

@@ -35,16 +35,18 @@ const {
   ObjectKeys,
   ObjectPrototypeIsPrototypeOf,
   ReflectApply,
-  RegExpPrototypeTest,
+  RegExpPrototypeExec,
   SafeMap,
   String,
   StringPrototypeCharCodeAt,
   StringPrototypeIncludes,
   StringPrototypeIndexOf,
-  StringPrototypeReplace,
   StringPrototypeSlice,
   StringPrototypeSplit,
   StringPrototypeStartsWith,
+  SafeRegExpPrototypeSymbolReplace,
+  SafeRegExpPrototypeTest,
+  makeSafeStringObject,
 } = primordials;
 
 const { Buffer } = require('buffer');
@@ -283,9 +285,11 @@ function parseCode(code, offset) {
 
   return [
     node.node.start,
-    StringPrototypeReplace(StringPrototypeSlice(code,
-                                                node.node.start, node.node.end),
-                           escapeSequencesRegExp, escapeFn),
+    SafeRegExpPrototypeSymbolReplace(
+      escapeSequencesRegExp,
+      StringPrototypeSlice(code, node.node.start, node.node.end),
+      escapeFn
+    ),
   ];
 }
 
@@ -357,17 +361,21 @@ function getErrMessage(message, fn) {
     }
     // Always normalize indentation, otherwise the message could look weird.
     if (StringPrototypeIncludes(message, '\n')) {
-      if (EOL === '\r\n') {
-        message = StringPrototypeReplace(message, /\r\n/g, '\n');
-      }
-      const frames = StringPrototypeSplit(message, '\n');
-      message = ArrayPrototypeShift(frames);
-      for (const frame of frames) {
-        let pos = 0;
-        while (pos < column && (frame[pos] === ' ' || frame[pos] === '\t')) {
+      const splitter = EOL === '\r\n' ? /\r\n/g : /\n/g;
+      const splitterLength = EOL === '\r\n' ? 2 : 1;
+      const str = message;
+      let previousIndex = RegExpPrototypeExec(splitter, str).index;
+      message = StringPrototypeSlice(message, 0, previousIndex);
+      while (previousIndex != null) {
+        const lineEndIndex = RegExpPrototypeExec(splitter, str)?.index;
+        previousIndex += splitterLength;
+        let pos = previousIndex;
+        while (pos < previousIndex + column &&
+               (str[pos] === ' ' || str[pos] === '\t')) {
           pos++;
         }
-        message += `\n  ${StringPrototypeSlice(frame, pos)}`;
+        message += `\n  ${StringPrototypeSlice(str, pos, lineEndIndex)}`;
+        previousIndex = lineEndIndex;
       }
     }
     message = `The expression evaluated to a falsy value:\n\n  ${message}\n`;
@@ -619,7 +627,7 @@ class Comparison {
         if (actual !== undefined &&
             typeof actual[key] === 'string' &&
             isRegExp(obj[key]) &&
-            RegExpPrototypeTest(obj[key], actual[key])) {
+            SafeRegExpPrototypeTest(obj[key], actual[key])) {
           this[key] = actual[key];
         } else {
           this[key] = obj[key];
@@ -665,7 +673,7 @@ function expectedException(actual, expected, message, fn) {
     // Handle regular expressions.
     if (isRegExp(expected)) {
       const str = String(actual);
-      if (RegExpPrototypeTest(expected, str))
+      if (SafeRegExpPrototypeTest(expected, str))
         return;
 
       if (!message) {
@@ -700,7 +708,7 @@ function expectedException(actual, expected, message, fn) {
       for (const key of keys) {
         if (typeof actual[key] === 'string' &&
             isRegExp(expected[key]) &&
-            RegExpPrototypeTest(expected[key], actual[key])) {
+            SafeRegExpPrototypeTest(expected[key], actual[key])) {
           continue;
         }
         compareExceptionKey(actual, expected, key, message, keys, fn);
@@ -864,7 +872,7 @@ function hasMatchingError(actual, expected) {
   if (typeof expected !== 'function') {
     if (isRegExp(expected)) {
       const str = String(actual);
-      return RegExpPrototypeTest(expected, str);
+      return SafeRegExpPrototypeTest(expected, str);
     }
     throw new ERR_INVALID_ARG_TYPE(
       'expected', ['Function', 'RegExp'], expected
@@ -978,10 +986,11 @@ assert.ifError = function ifError(err) {
       // This will remove any duplicated frames from the error frames taken
       // from within `ifError` and add the original error frames to the newly
       // created ones.
-      const tmp2 = StringPrototypeSplit(origStack, '\n');
+      const LINE_RETURN = makeSafeStringObject('\n');
+      const tmp2 = StringPrototypeSplit(origStack, LINE_RETURN);
       ArrayPrototypeShift(tmp2);
       // Filter all frames existing in err.stack.
-      let tmp1 = StringPrototypeSplit(newErr.stack, '\n');
+      let tmp1 = StringPrototypeSplit(newErr.stack, LINE_RETURN);
       for (const errFrame of tmp2) {
         // Find the first occurrence of the frame.
         const pos = ArrayPrototypeIndexOf(tmp1, errFrame);
@@ -1007,7 +1016,7 @@ function internalMatch(string, regexp, message, fn) {
   }
   const match = fn.name === 'match';
   if (typeof string !== 'string' ||
-      RegExpPrototypeTest(regexp, string) !== match) {
+      SafeRegExpPrototypeTest(regexp, string) !== match) {
     if (message instanceof Error) {
       throw message;
     }

lib/internal/assert/assertion_error.js

@@ -15,6 +15,7 @@ const {
   StringPrototypeRepeat,
   StringPrototypeSlice,
   StringPrototypeSplit,
+  makeSafeStringObject,
 } = primordials;
 
 const { inspect } = require('internal/util/inspect');
@@ -80,14 +81,16 @@ function inspectValue(val) {
   );
 }
 
+const SAFE_LINE_RETURN = makeSafeStringObject('\n');
 function createErrDiff(actual, expected, operator) {
   let other = '';
   let res = '';
   let end = '';
   let skipped = false;
   const actualInspected = inspectValue(actual);
-  const actualLines = StringPrototypeSplit(actualInspected, '\n');
-  const expectedLines = StringPrototypeSplit(inspectValue(expected), '\n');
+  const actualLines = StringPrototypeSplit(actualInspected, SAFE_LINE_RETURN);
+  const expectedLines = StringPrototypeSplit(inspectValue(expected),
+                                             SAFE_LINE_RETURN);
 
   let i = 0;
   let indicator = '';
@@ -164,7 +167,7 @@ function createErrDiff(actual, expected, operator) {
   // E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() })
   if (maxLines === 0) {
     // We have to get the result again. The lines were all removed before.
-    const actualLines = StringPrototypeSplit(actualInspected, '\n');
+    const actualLines = StringPrototypeSplit(actualInspected, SAFE_LINE_RETURN);
 
     // Only remove lines in case it makes sense to collapse those.
     // TODO: Accept env to always show the full error.
@@ -315,7 +318,7 @@ function createErrDiff(actual, expected, operator) {
 }
 
 function addEllipsis(string) {
-  const lines = StringPrototypeSplit(string, '\n', 11);
+  const lines = StringPrototypeSplit(string, SAFE_LINE_RETURN, 11);
   if (lines.length > 10) {
     lines.length = 10;
     return `${ArrayPrototypeJoin(lines, '\n')}\n...`;
@@ -380,7 +383,8 @@ class AssertionError extends Error {
         // In case the objects are equal but the operator requires unequal, show
         // the first object and say A equals B
         let base = kReadableOperator[operator];
-        const res = StringPrototypeSplit(inspectValue(actual), '\n');
+        const res = StringPrototypeSplit(inspectValue(actual),
+                                         SAFE_LINE_RETURN);
 
         // In case "actual" is an object or a function, it should not be
         // reference equal.