test_runner: reimplement assert.ok to allow stack parsing

PR-URL: #54776
Refs: nodejs/help#4461
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

Author: avivkeller

lib/assert.js

@@ -24,31 +24,21 @@ const {
  ArrayPrototypeIndexOf,
  ArrayPrototypeJoin,
  ArrayPrototypePush,
- ArrayPrototypeShift,
  ArrayPrototypeSlice,
  Error,
- ErrorCaptureStackTrace,
- FunctionPrototypeBind,
  NumberIsNaN,
  ObjectAssign,
  ObjectIs,
  ObjectKeys,
  ObjectPrototypeIsPrototypeOf,
  ReflectApply,
  RegExpPrototypeExec,
- RegExpPrototypeSymbolReplace,
- SafeMap,
  String,
- StringPrototypeCharCodeAt,
- StringPrototypeIncludes,
  StringPrototypeIndexOf,
- StringPrototypeReplace,
  StringPrototypeSlice,
  StringPrototypeSplit,
- StringPrototypeStartsWith,
 }=primordials;
 
-const{ Buffer }=require('buffer');
 const{
 codes: {
 ERR_AMBIGUOUS_ARGUMENT,
@@ -57,53 +47,27 @@ const {
 ERR_INVALID_RETURN_VALUE,
 ERR_MISSING_ARGS,
 },
- isErrorStackTraceLimitWritable,
- overrideStackTrace,
 }=require('internal/errors');
 constAssertionError=require('internal/assert/assertion_error');
-const{ openSync, closeSync, readSync }=require('fs');
 const{ inspect }=require('internal/util/inspect');
 const{ isPromise, isRegExp }=require('internal/util/types');
-const{EOL}=require('internal/constants');
-const{ BuiltinModule }=require('internal/bootstrap/realm');
 const{ isError, deprecate }=require('internal/util');
+const{ innerOk }=require('internal/assert/utils');
 
-consterrorCache=newSafeMap();
 constCallTracker=require('internal/assert/calltracker');
 const{
  validateFunction,
 }=require('internal/validators');
-const{ fileURLToPath }=require('internal/url');
 
 letisDeepEqual;
 letisDeepStrictEqual;
-letparseExpressionAt;
-letfindNodeAround;
-lettokenizer;
-letdecoder;
 
 functionlazyLoadComparison(){
 constcomparison=require('internal/util/comparisons');
 isDeepEqual=comparison.isDeepEqual;
 isDeepStrictEqual=comparison.isDeepStrictEqual;
 }
 
-// Escape control characters but not \n and \t to keep the line breaks and
-// indentation intact.
-// eslint-disable-next-line no-control-regex
-constescapeSequencesRegExp=/[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
-constmeta=[
-'\\u0000','\\u0001','\\u0002','\\u0003','\\u0004',
-'\\u0005','\\u0006','\\u0007','\\b','',
-'','\\u000b','\\f','','\\u000e',
-'\\u000f','\\u0010','\\u0011','\\u0012','\\u0013',
-'\\u0014','\\u0015','\\u0016','\\u0017','\\u0018',
-'\\u0019','\\u001a','\\u001b','\\u001c','\\u001d',
-'\\u001e','\\u001f',
-];
-
-constescapeFn=(str)=>meta[StringPrototypeCharCodeAt(str,0)];
-
 letwarned=false;
 
 // The assert module provides functions that throw
@@ -178,237 +142,6 @@ assert.fail = fail;
 // The AssertionError is defined in internal/error.
 assert.AssertionError=AssertionError;
 
-functionfindColumn(fd,column,code){
-if(code.length>column+100){
-try{
-returnparseCode(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
-thrownull;
-}
-}
-}
-// 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.
-constbytesToRead=column-code.length+2500;
-constbuffer=Buffer.allocUnsafe(bytesToRead);
-constbytesRead=readSync(fd,buffer,0,bytesToRead);
-code+=decoder.write(buffer.slice(0,bytesRead));
-// EOF: fast path.
-if(bytesRead<bytesToRead){
-returnparseCode(code,column);
-}
-// Read potentially missing code.
-returnfindColumn(fd,column,code);
-}
-
-functiongetCode(fd,line,column){
-letbytesRead=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.
-returnfindColumn(fd,column,'');
-}
-letlines=0;
-// Prevent blocking the event loop by limiting the maximum amount of
-// data that may be read.
-letmaxReads=32;// bytesPerRead * maxReads = 512 KiB
-constbytesPerRead=16384;
-// Use a single buffer up front that is reused until the call site is found.
-letbuffer=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(leti=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){
-returnparseCode(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.
-constcode=decoder.write(buffer.slice(i+1,bytesRead));
-returnfindColumn(fd,column,code);
-}
-}
-}
-}
-
-functionparseCode(code,offset){
-// Lazy load acorn.
-if(parseExpressionAt===undefined){
-constParser=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);
-}
-letnode;
-letstart;
-// Parse the read code until the correct expression is found.
-for(consttokenoftokenizer(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
-thrownull;
-}
-
-functiongetErrMessage(message,fn){
-consttmpLimit=Error.stackTraceLimit;
-consterrorStackTraceLimitIsWritable=isErrorStackTraceLimitWritable();
-// Make sure the limit is set to 1. Otherwise it could fail (<= 0) or it
-// does to much work.
-if(errorStackTraceLimitIsWritable)Error.stackTraceLimit=1;
-// We only need the stack trace. To minimize the overhead use an object
-// instead of an error.
-consterr={};
-ErrorCaptureStackTrace(err,fn);
-if(errorStackTraceLimitIsWritable)Error.stackTraceLimit=tmpLimit;
-
-overrideStackTrace.set(err,(_,stack)=>stack);
-constcall=err.stack[0];
-
-letfilename=call.getFileName();
-constline=call.getLineNumber()-1;
-letcolumn=call.getColumnNumber()-1;
-letidentifier;
-letcode;
-
-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{
-returnmessage;
-}
-
-if(errorCache.has(identifier)){
-returnerrorCache.get(identifier);
-}
-
-letfd;
-try{
-// Set the stack trace limit to zero. This makes sure unexpected token
-// errors are handled faster.
-if(errorStackTraceLimitIsWritable)Error.stackTraceLimit=0;
-
-if(filename){
-if(decoder===undefined){
-const{ StringDecoder }=require('string_decoder');
-decoder=newStringDecoder('utf8');
-}
-
-// ESM file prop is a file proto. Convert that to path.
-// This ensure opensync will not throw ENOENT for ESM files.
-constfileProtoPrefix='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();
-}else{
-for(leti=0;i<line;i++){
-code=StringPrototypeSlice(code,
-StringPrototypeIndexOf(code,'\n')+1);
-}
-({0: column,1: message}=parseCode(code,column));
-}
-// Always normalize indentation, otherwise the message could look weird.
-if(StringPrototypeIncludes(message,'\n')){
-if(EOL==='\r\n'){
-message=RegExpPrototypeSymbolReplace(/\r\n/g,message,'\n');
-}
-constframes=StringPrototypeSplit(message,'\n');
-message=ArrayPrototypeShift(frames);
-for(constframeofframes){
-letpos=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);
-
-returnmessage;
-}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);
-}
-}
-
-functioninnerOk(fn,argLen,value,message){
-if(!value){
-letgeneratedMessage=false;
-
-if(argLen===0){
-generatedMessage=true;
-message='No value argument passed to `assert.ok()`';
-}elseif(message==null){
-generatedMessage=true;
-message=getErrMessage(message,fn);
-}elseif(isError(message)){
-throwmessage;
-}
-
-consterr=newAssertionError({
-actual: value,
-expected: true,
- message,
-operator: '==',
-stackStartFn: fn,
-});
-err.generatedMessage=generatedMessage;
-throwerr;
-}
-}
-
 /**
  * Pure assertion tests whether a value is truthy, as determined
  * by !!value.