nodejs
diff --git a/‎lib/internal/assert/utils.js‎
Lines changed: 9 additions & 205 deletions b/‎lib/internal/assert/utils.js‎
Lines changed: 9 additions & 205 deletions
diff --git a/‎lib/internal/errors/error_source.js‎
Lines changed: 133 additions & 0 deletions b/‎lib/internal/errors/error_source.js‎
Lines changed: 133 additions & 0 deletions
@@ -1,38 +1,21 @@
 'use strict';
 
 const {
-  ArrayPrototypeShift,
   Error,
   ErrorCaptureStackTrace,
-  FunctionPrototypeBind,
-  RegExpPrototypeSymbolReplace,
-  SafeMap,
   StringPrototypeCharCodeAt,
-  StringPrototypeIncludes,
   StringPrototypeReplace,
-  StringPrototypeSlice,
-  StringPrototypeSplit,
-  StringPrototypeStartsWith,
 } = primordials;
 
-const { Buffer } = require('buffer');
 const {
   isErrorStackTraceLimitWritable,
-  overrideStackTrace,
 } = require('internal/errors');
 const AssertionError = require('internal/assert/assertion_error');
-const { openSync, closeSync, readSync } = require('fs');
-const { EOL } = require('internal/constants');
-const { BuiltinModule } = require('internal/bootstrap/realm');
 const { isError } = require('internal/util');
 
-const errorCache = new SafeMap();
-const { fileURLToPath } = require('internal/url');
-
-let parseExpressionAt;
-let findNodeAround;
-let tokenizer;
-let decoder;
+const {
+  getErrorSourceExpression,
+} = require('internal/errors/error_source');
 
 // Escape control characters but not \n and \t to keep the line breaks and
 // indentation intact.
@@ -50,111 +33,7 @@ const meta = [
 
 const escapeFn = (str) => meta[StringPrototypeCharCodeAt(str, 0)];
 
-function findColumn(fd, column, code) {
-  if (code.length > column + 100) {
-    try {
-      return parseCode(code, column);
-    } catch {
-      // End recursion in case no code could be parsed. The expression should
-      // have been found after 2500 characters, so stop trying.
-      if (code.length - column > 2500) {
-        // eslint-disable-next-line no-throw-literal
-        throw null;
-      }
-    }
-  }
-  // Read up to 2500 bytes more than necessary in columns. That way we address
-  // multi byte characters and read enough data to parse the code.
-  const bytesToRead = column - code.length + 2500;
-  const buffer = Buffer.allocUnsafe(bytesToRead);
-  const bytesRead = readSync(fd, buffer, 0, bytesToRead);
-  code += decoder.write(buffer.slice(0, bytesRead));
-  // EOF: fast path.
-  if (bytesRead < bytesToRead) {
-    return parseCode(code, column);
-  }
-  // Read potentially missing code.
-  return findColumn(fd, column, code);
-}
-
-function getCode(fd, line, column) {
-  let bytesRead = 0;
-  if (line === 0) {
-    // Special handle line number one. This is more efficient and simplifies the
-    // rest of the algorithm. Read more than the regular column number in bytes
-    // to prevent multiple reads in case multi byte characters are used.
-    return findColumn(fd, column, '');
-  }
-  let lines = 0;
-  // Prevent blocking the event loop by limiting the maximum amount of
-  // data that may be read.
-  let maxReads = 32; // bytesPerRead * maxReads = 512 KiB
-  const bytesPerRead = 16384;
-  // Use a single buffer up front that is reused until the call site is found.
-  let buffer = Buffer.allocUnsafe(bytesPerRead);
-  while (maxReads-- !== 0) {
-    // Only allocate a new buffer in case the needed line is found. All data
-    // before that can be discarded.
-    buffer = lines < line ? buffer : Buffer.allocUnsafe(bytesPerRead);
-    bytesRead = readSync(fd, buffer, 0, bytesPerRead);
-    // Read the buffer until the required code line is found.
-    for (let i = 0; i < bytesRead; i++) {
-      if (buffer[i] === 10 && ++lines === line) {
-        // If the end of file is reached, directly parse the code and return.
-        if (bytesRead < bytesPerRead) {
-          return parseCode(buffer.toString('utf8', i + 1, bytesRead), column);
-        }
-        // Check if the read code is sufficient or read more until the whole
-        // expression is read. Make sure multi byte characters are preserved
-        // properly by using the decoder.
-        const code = decoder.write(buffer.slice(i + 1, bytesRead));
-        return findColumn(fd, column, code);
-      }
-    }
-  }
-}
-
-function parseCode(code, offset) {
-  // Lazy load acorn.
-  if (parseExpressionAt === undefined) {
-    const Parser = require('internal/deps/acorn/acorn/dist/acorn').Parser;
-    ({ findNodeAround } = require('internal/deps/acorn/acorn-walk/dist/walk'));
-
-    parseExpressionAt = FunctionPrototypeBind(Parser.parseExpressionAt, Parser);
-    tokenizer = FunctionPrototypeBind(Parser.tokenizer, Parser);
-  }
-  let node;
-  let start;
-  // Parse the read code until the correct expression is found.
-  for (const token of tokenizer(code, { ecmaVersion: 'latest' })) {
-    start = token.start;
-    if (start > offset) {
-      // No matching expression found. This could happen if the assert
-      // expression is bigger than the provided buffer.
-      break;
-    }
-    try {
-      node = parseExpressionAt(code, start, { ecmaVersion: 'latest' });
-      // Find the CallExpression in the tree.
-      node = findNodeAround(node, offset, 'CallExpression');
-      if (node?.node.end >= offset) {
-        return [
-          node.node.start,
-          StringPrototypeReplace(StringPrototypeSlice(code,
-                                                      node.node.start, node.node.end),
-                                 escapeSequencesRegExp, escapeFn),
-        ];
-      }
-    // eslint-disable-next-line no-unused-vars
-    } catch (err) {
-      continue;
-    }
-  }
-  // eslint-disable-next-line no-throw-literal
-  throw null;
-}
-
-function getErrMessage(message, fn) {
+function getErrMessage(fn) {
   const tmpLimit = Error.stackTraceLimit;
   const errorStackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
   // Make sure the limit is set to 1. Otherwise it could fail (<= 0) or it
@@ -166,85 +45,10 @@ function getErrMessage(message, fn) {
   ErrorCaptureStackTrace(err, fn);
   if (errorStackTraceLimitIsWritable) Error.stackTraceLimit = tmpLimit;
 
-  overrideStackTrace.set(err, (_, stack) => stack);
-  const call = err.stack[0];
-
-  let filename = call.getFileName();
-  const line = call.getLineNumber() - 1;
-  let column = call.getColumnNumber() - 1;
-  let identifier;
-
-  if (filename) {
-    identifier = `${filename}${line}${column}`;
-
-    // Skip Node.js modules!
-    if (StringPrototypeStartsWith(filename, 'node:') &&
-        BuiltinModule.exists(StringPrototypeSlice(filename, 5))) {
-      errorCache.set(identifier, undefined);
-      return;
-    }
-  } else {
-    return message;
-  }
-
-  if (errorCache.has(identifier)) {
-    return errorCache.get(identifier);
-  }
-
-  let fd;
-  try {
-    // Set the stack trace limit to zero. This makes sure unexpected token
-    // errors are handled faster.
-    if (errorStackTraceLimitIsWritable) Error.stackTraceLimit = 0;
-
-    if (decoder === undefined) {
-      const { StringDecoder } = require('string_decoder');
-      decoder = new StringDecoder('utf8');
-    }
-
-    // ESM file prop is a file proto. Convert that to path.
-    // This ensure opensync will not throw ENOENT for ESM files.
-    const fileProtoPrefix = 'file://';
-    if (StringPrototypeStartsWith(filename, fileProtoPrefix)) {
-      filename = fileURLToPath(filename);
-    }
-
-    fd = openSync(filename, 'r', 0o666);
-    // Reset column and message.
-    ({ 0: column, 1: message } = getCode(fd, line, column));
-    // Flush unfinished multi byte characters.
-    decoder.end();
-
-    // Always normalize indentation, otherwise the message could look weird.
-    if (StringPrototypeIncludes(message, '\n')) {
-      if (EOL === '\r\n') {
-        message = RegExpPrototypeSymbolReplace(/\r\n/g, message, '\n');
-      }
-      const frames = StringPrototypeSplit(message, '\n');
-      message = ArrayPrototypeShift(frames);
-      for (let i = 0; i < frames.length; i++) {
-        const frame = frames[i];
-        let pos = 0;
-        while (pos < column && (frame[pos] === ' ' || frame[pos] === '\t')) {
-          pos++;
-        }
-        message += `\n  ${StringPrototypeSlice(frame, pos)}`;
-      }
-    }
-    message = `The expression evaluated to a falsy value:\n\n  ${message}\n`;
-    // Make sure to always set the cache! No matter if the message is
-    // undefined or not
-    errorCache.set(identifier, message);
-
-    return message;
-  } catch {
-    // Invalidate cache to prevent trying to read this part again.
-    errorCache.set(identifier, undefined);
-  } finally {
-    // Reset limit.
-    if (errorStackTraceLimitIsWritable) Error.stackTraceLimit = tmpLimit;
-    if (fd !== undefined)
-      closeSync(fd);
+  let source = getErrorSourceExpression(err);
+  if (source) {
+    source = StringPrototypeReplace(source, escapeSequencesRegExp, escapeFn);
+    return `The expression evaluated to a falsy value:\n\n  ${source}\n`;
   }
 }
 
@@ -257,7 +61,7 @@ function innerOk(fn, argLen, value, message) {
       message = 'No value argument passed to `assert.ok()`';
     } else if (message == null) {
       generatedMessage = true;
-      message = getErrMessage(message, fn);
+      message = getErrMessage(fn);
     } else if (isError(message)) {
       throw message;
     }
 
@@ -0,0 +1,133 @@
+'use strict';
+
+const {
+  FunctionPrototypeBind,
+  StringPrototypeSlice,
+} = primordials;
+
+const {
+  getErrorSourcePositions,
+} = internalBinding('errors');
+
+/**
+ * Get the source location of an error.
+ *
+ * The `error.stack` must not have been accessed. The resolution is based on the structured
+ * error stack data.
+ * @param {Error|object} error An error object, or an object being invoked with ErrorCaptureStackTrace
+ * @returns {{sourceLine: string, startColumn: number}|undefined}
+ */
+function getErrorSourceLocation(error) {
+  const pos = getErrorSourcePositions(error);
+  const {
+    sourceLine,
+    startColumn,
+  } = pos;
+
+  return { sourceLine, startColumn };
+}
+
+const memberAccessTokens = [ '.', '?.', '[', ']' ];
+const memberNameTokens = [ 'name', 'string', 'num' ];
+let tokenizer;
+/**
+ * Get the first expression in a code string at the startColumn.
+ * @param {string} code source code line
+ * @param {number} startColumn which column the error is constructed
+ * @returns {string}
+ */
+function getFirstExpression(code, startColumn) {
+  // Lazy load acorn.
+  if (tokenizer === undefined) {
+    const Parser = require('internal/deps/acorn/acorn/dist/acorn').Parser;
+    tokenizer = FunctionPrototypeBind(Parser.tokenizer, Parser);
+  }
+
+  let lastToken;
+  let firstMemberAccessNameToken;
+  let terminatingCol;
+  let parenLvl = 0;
+  // Tokenize the line to locate the expression at the startColumn.
+  // The source line may be an incomplete JavaScript source, so do not parse the source line.
+  for (const token of tokenizer(code, { ecmaVersion: 'latest' })) {
+    // Peek before the startColumn.
+    if (token.start < startColumn) {
+      // There is a semicolon. This is a statement before the startColumn, so reset the memo.
+      if (token.type.label === ';') {
+        firstMemberAccessNameToken = null;
+        continue;
+      }
+      // Try to memo the member access expressions before the startColumn, so that the
+      // returned source code contains more info:
+      //   assert.ok(value)
+      //          ^ startColumn
+      // The member expression can also be like
+      //   assert['ok'](value) or assert?.ok(value)
+      //               ^ startColumn      ^ startColumn
+      if (memberAccessTokens.includes(token.type.label) && lastToken?.type.label === 'name') {
+        // First member access name token must be a 'name'.
+        firstMemberAccessNameToken ??= lastToken;
+      } else if (!memberAccessTokens.includes(token.type.label) &&
+        !memberNameTokens.includes(token.type.label)) {
+        // Reset the memo if it is not a simple member access.
+        // For example: assert[(() => 'ok')()](value)
+        //                                    ^ startColumn
+        firstMemberAccessNameToken = null;
+      }
+      lastToken = token;
+      continue;
+    }
+    // Now after the startColumn, this must be an expression.
+    if (token.type.label === '(') {
+      parenLvl++;
+      continue;
+    }
+    if (token.type.label === ')') {
+      parenLvl--;
+      if (parenLvl === 0) {
+        // A matched closing parenthesis found after the startColumn,
+        // terminate here. Include the token.
+        //   (assert.ok(false), assert.ok(true))
+        //           ^ startColumn
+        terminatingCol = token.start + 1;
+        break;
+      }
+      continue;
+    }
+    if (token.type.label === ';') {
+      // A semicolon found after the startColumn, terminate here.
+      //   assert.ok(false); assert.ok(true));
+      //          ^ startColumn
+      terminatingCol = token;
+      break;
+    }
+    // If no semicolon found after the startColumn. The string after the
+    // startColumn must be the expression.
+    //   assert.ok(false)
+    //          ^ startColumn
+  }
+  const start = firstMemberAccessNameToken?.start ?? startColumn;
+  return StringPrototypeSlice(code, start, terminatingCol);
+}
+
+/**
+ * Get the source expression of an error.
+ *
+ * The `error.stack` must not have been accessed, or the source location may be incorrect. The
+ * resolution is based on the structured error stack data.
+ * @param {Error|object} error An error object, or an object being invoked with ErrorCaptureStackTrace
+ * @returns {string|undefined}
+ */
+function getErrorSourceExpression(error) {
+  const loc = getErrorSourceLocation(error);
+  if (loc === undefined) {
+    return;
+  }
+  const { sourceLine, startColumn } = loc;
+  return getFirstExpression(sourceLine, startColumn);
+}
+
+module.exports = {
+  getErrorSourceLocation,
+  getErrorSourceExpression,
+};