src: refactor tickInfo access

- Wrap access to tickInfo fields in functions
- Rename `kHasScheduled` to `kHasTickScheduled` and
`kHasPromiseRejections` to `kHasRejectionToWarn` for clarity - note
the latter will be set to false if the rejection does not lead to
a warning so the previous description is not accurate.
- Set `kHasRejectionToWarn` in JS land of relying on C++ to use
an implict contract (return value of the promise rejection handler)
to set it, as the decision is made entirely in JS land.
- Destructure promise reject event constants.
PR-URL: #25200
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: joyeecheung

lib/internal/process/next_tick.js

@@ -11,6 +11,8 @@ const {
 }=internalBinding('task_queue');
 
 const{
+ setHasRejectionToWarn,
+ hasRejectionToWarn,
  promiseRejectHandler,
  emitPromiseRejectionWarnings
 }=require('internal/process/promises');
@@ -30,15 +32,21 @@ const { ERR_INVALID_CALLBACK } = require('internal/errors').codes;
 constFixedQueue=require('internal/fixed_queue');
 
 // *Must* match Environment::TickInfo::Fields in src/env.h.
-constkHasScheduled=0;
-constkHasPromiseRejections=1;
+constkHasTickScheduled=0;
+
+functionhasTickScheduled(){
+returntickInfo[kHasTickScheduled]===1;
+}
+functionsetHasTickScheduled(value){
+tickInfo[kHasTickScheduled]=value ? 1 : 0;
+}
 
 constqueue=newFixedQueue();
 
 functionrunNextTicks(){
-if(tickInfo[kHasScheduled]===0&&tickInfo[kHasPromiseRejections]===0)
+if(!hasTickScheduled()&&!hasRejectionToWarn())
 runMicrotasks();
-if(tickInfo[kHasScheduled]===0&&tickInfo[kHasPromiseRejections]===0)
+if(!hasTickScheduled()&&!hasRejectionToWarn())
 return;
 
 internalTickCallback();
@@ -70,10 +78,10 @@ function internalTickCallback() {
 
 emitAfter(asyncId);
 }
-tickInfo[kHasScheduled]=0;
+setHasTickScheduled(false);
 runMicrotasks();
 }while(!queue.isEmpty()||emitPromiseRejectionWarnings());
-tickInfo[kHasPromiseRejections]=0;
+setHasRejectionToWarn(false);
 }
 
 classTickObject{
@@ -119,7 +127,7 @@ function nextTick(callback) {
 }
 
 if(queue.isEmpty())
-tickInfo[kHasScheduled]=1;
+setHasTickScheduled(true);
 queue.push(newTickObject(callback,args,getDefaultTriggerAsyncId()));
 }
 

lib/internal/process/promises.js

@@ -2,24 +2,45 @@
 
 const{ safeToString }=internalBinding('util');
 const{
- promiseRejectEvents
+ tickInfo,
+promiseRejectEvents: {
+ kPromiseRejectWithNoHandler,
+ kPromiseHandlerAddedAfterReject,
+ kPromiseResolveAfterResolved,
+ kPromiseRejectAfterResolved
+}
 }=internalBinding('task_queue');
 
+// *Must* match Environment::TickInfo::Fields in src/env.h.
+constkHasRejectionToWarn=1;
+
 constmaybeUnhandledPromises=newWeakMap();
 constpendingUnhandledRejections=[];
 constasyncHandledRejections=[];
 letlastPromiseId=0;
 
+functionsetHasRejectionToWarn(value){
+tickInfo[kHasRejectionToWarn]=value ? 1 : 0;
+}
+
+functionhasRejectionToWarn(){
+returntickInfo[kHasRejectionToWarn]===1;
+}
+
 functionpromiseRejectHandler(type,promise,reason){
 switch(type){
-casepromiseRejectEvents.kPromiseRejectWithNoHandler:
-returnunhandledRejection(promise,reason);
-casepromiseRejectEvents.kPromiseHandlerAddedAfterReject:
-returnhandledRejection(promise);
-casepromiseRejectEvents.kPromiseResolveAfterResolved:
-returnresolveError('resolve',promise,reason);
-casepromiseRejectEvents.kPromiseRejectAfterResolved:
-returnresolveError('reject',promise,reason);
+casekPromiseRejectWithNoHandler:
+unhandledRejection(promise,reason);
+break;
+casekPromiseHandlerAddedAfterReject:
+handledRejection(promise);
+break;
+casekPromiseResolveAfterResolved:
+resolveError('resolve',promise,reason);
+break;
+casekPromiseRejectAfterResolved:
+resolveError('reject',promise,reason);
+break;
 }
 }
 
@@ -38,7 +59,7 @@ function unhandledRejection(promise, reason) {
 warned: false
 });
 pendingUnhandledRejections.push(promise);
-returntrue;
+setHasRejectionToWarn(true);
 }
 
 functionhandledRejection(promise){
@@ -54,10 +75,11 @@ function handledRejection(promise) {
 warning.name='PromiseRejectionHandledWarning';
 warning.id=uid;
 asyncHandledRejections.push({ promise, warning });
-returntrue;
+setHasRejectionToWarn(true);
+return;
 }
 }
-returnfalse;
+setHasRejectionToWarn(false);
 }
 
 constunhandledRejectionErrName='UnhandledPromiseRejectionWarning';
@@ -121,6 +143,8 @@ function emitPromiseRejectionWarnings() {
 }
 
 module.exports={
+ hasRejectionToWarn,
+ setHasRejectionToWarn,
  promiseRejectHandler,
  emitPromiseRejectionWarnings
 };

src/callback_scope.cc

@@ -95,7 +95,7 @@ void InternalCallbackScope::Close() {
  Environment::TickInfo* tick_info = env_->tick_info();
 
 if (!env_->can_call_into_js()) return;
-if (!tick_info->has_scheduled()) {
+if (!tick_info->has_tick_scheduled()) {
  env_->isolate()->RunMicrotasks();
  }
 
@@ -106,7 +106,7 @@ void InternalCallbackScope::Close() {
 CHECK_EQ(env_->trigger_async_id(), 0);
  }
 
-if (!tick_info->has_scheduled() && !tick_info->has_promise_rejections()) {
+if (!tick_info->has_tick_scheduled() && !tick_info->has_rejection_to_warn()) {
 return;
  }
 

src/env-inl.h

@@ -265,16 +265,12 @@ inline AliasedBuffer<uint8_t, v8::Uint8Array>& Environment::TickInfo::fields() {
 return fields_;
 }
 
-inlineboolEnvironment::TickInfo::has_scheduled() const {
-return fields_[kHasScheduled] == 1;
+inlineboolEnvironment::TickInfo::has_tick_scheduled() const {
+return fields_[kHasTickScheduled] == 1;
 }
 
-inlineboolEnvironment::TickInfo::has_promise_rejections() const {
-return fields_[kHasPromiseRejections] == 1;
-}
-
-inlinevoidEnvironment::TickInfo::promise_rejections_toggle_on() {
- fields_[kHasPromiseRejections] = 1;
+inlineboolEnvironment::TickInfo::has_rejection_to_warn() const {
+return fields_[kHasRejectionToWarn] == 1;
 }
 
 inlinevoidEnvironment::AssignToContext(v8::Local<v8::Context> context,

src/env.h

@@ -572,18 +572,16 @@ class Environment {
 classTickInfo {
 public:
 inline AliasedBuffer<uint8_t, v8::Uint8Array>& fields();
-inlineboolhas_scheduled() const;
-inlineboolhas_promise_rejections() const;
-
-inlinevoidpromise_rejections_toggle_on();
+inlineboolhas_tick_scheduled() const;
+inlineboolhas_rejection_to_warn() const;
 
 private:
 friendclassEnvironment; // So we can call the constructor.
 inlineexplicitTickInfo(v8::Isolate* isolate);
 
 enum Fields {
-kHasScheduled,
-kHasPromiseRejections,
+kHasTickScheduled = 0,
+kHasRejectionToWarn,
 kFieldsCount
  };
 

src/node_task_queue.cc

@@ -17,7 +17,6 @@ using v8::kPromiseRejectAfterResolved;
 using v8::kPromiseRejectWithNoHandler;
 using v8::kPromiseResolveAfterResolved;
 using v8::Local;
-using v8::MaybeLocal;
 using v8::Number;
 using v8::Object;
 using v8::Promise;
@@ -80,13 +79,8 @@ static void PromiseRejectCallback(PromiseRejectMessage message) {
  }
 
  Local<Value> args[] = { type, promise, value };
- MaybeLocal<Value> ret = callback->Call(env->context(),
-Undefined(isolate),
-arraysize(args),
- args);
-
-if (!ret.IsEmpty() && ret.ToLocalChecked()->IsTrue())
- env->tick_info()->promise_rejections_toggle_on();
+USE(callback->Call(
+ env->context(), Undefined(isolate), arraysize(args), args));
 }
 
 staticvoidInitializePromiseRejectCallback(