src: add new CHECK macros

src/async_wrap.cc

@@ -310,7 +310,7 @@ static void PromiseHook(PromiseHookType type, Local<Promise> promise,
     }
   }
 
-  CHECK_NE(wrap, nullptr);
+  CHECK_NOT_NULL(wrap);
   if (type == PromiseHookType::kBefore) {
     env->async_hooks()->push_async_ids(
       wrap->get_async_id(), wrap->get_trigger_async_id());

src/callback_scope.cc

@@ -45,9 +45,7 @@ InternalCallbackScope::InternalCallbackScope(Environment* env,
     async_context_(asyncContext),
     object_(object),
     callback_scope_(env) {
-  if (expect == kRequireResource) {
-    CHECK(!object.IsEmpty());
-  }
+  CHECK_IMPLIES(expect == kRequireResource, !object.IsEmpty());
 
   if (!env->can_call_into_js()) {
     failed_ = true;

src/connection_wrap.cc

@@ -34,7 +34,7 @@ template <typename WrapType, typename UVType>
 void ConnectionWrap<WrapType, UVType>::OnConnection(uv_stream_t* handle,
                                                     int status) {
   WrapType* wrap_data = static_cast<WrapType*>(handle->data);
-  CHECK_NE(wrap_data, nullptr);
+  CHECK_NOT_NULL(wrap_data);
   CHECK_EQ(&wrap_data->handle_, reinterpret_cast<UVType*>(handle));
 
   Environment* env = wrap_data->env();
@@ -78,7 +78,7 @@ template <typename WrapType, typename UVType>
 void ConnectionWrap<WrapType, UVType>::AfterConnect(uv_connect_t* req,
                                                     int status) {
   ConnectWrap* req_wrap = static_cast<ConnectWrap*>(req->data);
-  CHECK_NE(req_wrap, nullptr);
+  CHECK_NOT_NULL(req_wrap);
   WrapType* wrap = static_cast<WrapType*>(req->handle->data);
   CHECK_EQ(req_wrap->env(), wrap->env());
   Environment* env = wrap->env();

src/env-inl.h

@@ -473,22 +473,22 @@ inline double Environment::get_default_trigger_async_id() {
 }
 
 inline double* Environment::heap_statistics_buffer() const {
-  CHECK_NE(heap_statistics_buffer_, nullptr);
+  CHECK_NOT_NULL(heap_statistics_buffer_);
   return heap_statistics_buffer_;
 }
 
 inline void Environment::set_heap_statistics_buffer(double* pointer) {
-  CHECK_EQ(heap_statistics_buffer_, nullptr);  // Should be set only once.
+  CHECK_NULL(heap_statistics_buffer_);  // Should be set only once.
   heap_statistics_buffer_ = pointer;
 }
 
 inline double* Environment::heap_space_statistics_buffer() const {
-  CHECK_NE(heap_space_statistics_buffer_, nullptr);
+  CHECK_NOT_NULL(heap_space_statistics_buffer_);
   return heap_space_statistics_buffer_;
 }
 
 inline void Environment::set_heap_space_statistics_buffer(double* pointer) {
-  CHECK_EQ(heap_space_statistics_buffer_, nullptr);  // Should be set only once.
+  CHECK_NULL(heap_space_statistics_buffer_);  // Should be set only once.
   heap_space_statistics_buffer_ = pointer;
 }
 
@@ -497,7 +497,7 @@ inline char* Environment::http_parser_buffer() const {
 }
 
 inline void Environment::set_http_parser_buffer(char* buffer) {
-  CHECK_EQ(http_parser_buffer_, nullptr);  // Should be set only once.
+  CHECK_NULL(http_parser_buffer_);  // Should be set only once.
   http_parser_buffer_ = buffer;
 }
 

src/env.cc

@@ -80,7 +80,7 @@ IsolateData::~IsolateData() {
 v8::CpuProfiler* IsolateData::GetCpuProfiler() {
   if (cpu_profiler_ != nullptr) return cpu_profiler_;
   cpu_profiler_ = v8::CpuProfiler::New(isolate());
-  CHECK_NE(cpu_profiler_, nullptr);
+  CHECK_NOT_NULL(cpu_profiler_);
   return cpu_profiler_;
 }
 

src/fs_event_wrap.cc

@@ -88,7 +88,7 @@ FSEventWrap::~FSEventWrap() {
 
 void FSEventWrap::GetInitialized(const FunctionCallbackInfo<Value>& args) {
   FSEventWrap* wrap = Unwrap<FSEventWrap>(args.This());
-  CHECK(wrap != nullptr);
+  CHECK_NOT_NULL(wrap);
   args.GetReturnValue().Set(wrap->initialized_);
 }
 
@@ -133,14 +133,14 @@ void FSEventWrap::Start(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
   FSEventWrap* wrap = Unwrap<FSEventWrap>(args.This());
-  CHECK_NE(wrap, nullptr);
+  CHECK_NOT_NULL(wrap);
   CHECK(!wrap->initialized_);
 
   const int argc = args.Length();
   CHECK_GE(argc, 4);
 
   BufferValue path(env->isolate(), args[0]);
-  CHECK_NE(*path, nullptr);
+  CHECK_NOT_NULL(*path);
 
   unsigned int flags = 0;
   if (args[2]->IsTrue())
@@ -233,7 +233,7 @@ void FSEventWrap::OnEvent(uv_fs_event_t* handle, const char* filename,
 
 void FSEventWrap::Close(const FunctionCallbackInfo<Value>& args) {
   FSEventWrap* wrap = Unwrap<FSEventWrap>(args.Holder());
-  CHECK_NE(wrap, nullptr);
+  CHECK_NOT_NULL(wrap);
   CHECK(wrap->initialized_);
 
   wrap->initialized_ = false;

src/inspector_agent.cc

@@ -317,7 +317,7 @@ class InspectorTimerHandle {
   InspectorTimerHandle(const InspectorTimerHandle&) = delete;
 
   ~InspectorTimerHandle() {
-    CHECK_NE(timer_, nullptr);
+    CHECK_NOT_NULL(timer_);
     timer_->Stop();
     timer_ = nullptr;
   }
@@ -562,7 +562,7 @@ bool Agent::StartIoThread(bool wait_for_connect) {
   if (io_ != nullptr)
     return true;
 
-  CHECK_NE(client_, nullptr);
+  CHECK_NOT_NULL(client_);
 
   io_ = std::unique_ptr<InspectorIo>(
       new InspectorIo(parent_env_, platform_, path_, debug_options_,
@@ -613,7 +613,7 @@ std::unique_ptr<InspectorSession> Agent::Connect(
 }
 
 void Agent::WaitForDisconnect() {
-  CHECK_NE(client_, nullptr);
+  CHECK_NOT_NULL(client_);
   // TODO(addaleax): Maybe this should use an at-exit hook for the Environment
   // or something similar?
   client_->contextDestroyed(parent_env_->context());

src/inspector_io.cc

@@ -34,7 +34,7 @@ std::string ScriptPath(uv_loop_t* loop, const std::string& script_name) {
     uv_fs_t req;
     req.ptr = nullptr;
     if (0 == uv_fs_realpath(loop, &req, script_name.c_str(), nullptr)) {
-      CHECK_NE(req.ptr, nullptr);
+      CHECK_NOT_NULL(req.ptr);
       script_path = std::string(static_cast<char*>(req.ptr));
     }
     uv_fs_req_cleanup(&req);
@@ -197,7 +197,7 @@ bool InspectorIo::Start() {
 }
 
 void InspectorIo::Stop() {
-  CHECK(state_ == State::kAccepting || !sessions_.empty());
+  CHECK_IMPLIES(sessions_.empty(), state_ == State::kAccepting);
   Write(TransportAction::kKill, 0, StringView());
   int err = uv_thread_join(&thread_);
   CHECK_EQ(err, 0);

src/inspector_socket.cc

@@ -599,7 +599,7 @@ class HttpHandler : public ProtocolHandler {
 ProtocolHandler::ProtocolHandler(InspectorSocket* inspector,
                                  TcpHolder::Pointer tcp)
                                  : inspector_(inspector), tcp_(std::move(tcp)) {
-  CHECK_NE(nullptr, tcp_);
+  CHECK_NOT_NULL(tcp_);
   tcp_->SetHandler(this);
 }
 

src/js_stream.cc

@@ -104,7 +104,7 @@ int JSStream::DoWrite(WriteWrap* w,
                       uv_buf_t* bufs,
                       size_t count,
                       uv_stream_t* send_handle) {
-  CHECK_EQ(send_handle, nullptr);
+  CHECK_NULL(send_handle);
 
   HandleScope scope(env()->isolate());
   Context::Scope context_scope(env()->context());

src/module_wrap.cc

@@ -106,7 +106,7 @@ void ModuleWrap::New(const FunctionCallbackInfo<Value>& args) {
       ContextifyContext* sandbox =
           ContextifyContext::ContextFromContextifiedSandbox(
               env, args[2].As<Object>());
-      CHECK_NE(sandbox, nullptr);
+      CHECK_NOT_NULL(sandbox);
       context = sandbox->context();
     }
 

src/node.cc

@@ -1964,7 +1964,7 @@ static void DLOpen(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   auto context = env->context();
 
-  CHECK_EQ(modpending, nullptr);
+  CHECK_NULL(modpending);
 
   if (args.Length() < 2) {
     env->ThrowError("process.dlopen needs at least 2 arguments.");
@@ -2231,8 +2231,8 @@ static Local<Object> InitModule(Environment* env,
                                  Local<String> module) {
   Local<Object> exports = Object::New(env->isolate());
   // Internal bindings don't have a "module" object, only exports.
-  CHECK_EQ(mod->nm_register_func, nullptr);
-  CHECK_NE(mod->nm_context_register_func, nullptr);
+  CHECK_NULL(mod->nm_register_func);
+  CHECK_NOT_NULL(mod->nm_context_register_func);
   Local<Value> unused = Undefined(env->isolate());
   mod->nm_context_register_func(exports,
                                 unused,
@@ -4078,7 +4078,7 @@ void AtExit(void (*cb)(void* arg), void* arg) {
 
 
 void AtExit(Environment* env, void (*cb)(void* arg), void* arg) {
-  CHECK_NE(env, nullptr);
+  CHECK_NOT_NULL(env);
   env->AtExit(cb, arg);
 }
 
@@ -4339,7 +4339,7 @@ inline int Start(uv_loop_t* event_loop,
 
   {
     Mutex::ScopedLock scoped_lock(node_isolate_mutex);
-    CHECK_EQ(node_isolate, nullptr);
+    CHECK_NULL(node_isolate);
     node_isolate = isolate;
   }
 

src/node_buffer.cc

@@ -140,7 +140,7 @@ CallbackInfo::CallbackInfo(Isolate* isolate,
   ArrayBuffer::Contents obj_c = object->GetContents();
   CHECK_EQ(data_, static_cast<char*>(obj_c.Data()));
   if (object->ByteLength() != 0)
-    CHECK_NE(data_, nullptr);
+    CHECK_NOT_NULL(data_);
 
   persistent_.SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
   persistent_.SetWrapperClassId(BUFFER_ID);
@@ -329,7 +329,7 @@ MaybeLocal<Object> Copy(Environment* env, const char* data, size_t length) {
 
   void* new_data;
   if (length > 0) {
-    CHECK_NE(data, nullptr);
+    CHECK_NOT_NULL(data);
     new_data = node::UncheckedMalloc(length);
     if (new_data == nullptr)
       return Local<Object>();
@@ -408,7 +408,7 @@ MaybeLocal<Object> New(Isolate* isolate, char* data, size_t length) {
 
 MaybeLocal<Object> New(Environment* env, char* data, size_t length) {
   if (length > 0) {
-    CHECK_NE(data, nullptr);
+    CHECK_NOT_NULL(data);
     CHECK(length <= kMaxLength);
   }
 

src/node_contextify.cc

@@ -655,7 +655,7 @@ class ContextifyScript : public BaseObject {
         ContextifyContext* sandbox =
             ContextifyContext::ContextFromContextifiedSandbox(
                 env, args[6].As<Object>());
-        CHECK_NE(sandbox, nullptr);
+        CHECK_NOT_NULL(sandbox);
         parsing_context = sandbox->context();
       }
     } else {
@@ -785,7 +785,7 @@ class ContextifyScript : public BaseObject {
     // Get the context from the sandbox
     ContextifyContext* contextify_context =
         ContextifyContext::ContextFromContextifiedSandbox(env, sandbox);
-    CHECK_NE(contextify_context, nullptr);
+    CHECK_NOT_NULL(contextify_context);
 
     if (contextify_context->context().IsEmpty())
       return;

src/node_crypto.cc

@@ -731,7 +731,7 @@ static X509_STORE* NewRootCertStore() {
       BIO_free(bp);
 
       // Parse errors from the built-in roots are fatal.
-      CHECK_NE(x509, nullptr);
+      CHECK_NOT_NULL(x509);
 
       root_certs_vector.push_back(x509);
     }
@@ -1579,7 +1579,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
     int rv;
 
     ext = X509_get_ext(cert, index);
-    CHECK_NE(ext, nullptr);
+    CHECK_NOT_NULL(ext);
 
     if (!SafeX509ExtPrint(bio.get(), ext)) {
       rv = X509V3_EXT_print(bio.get(), ext, 0, 0);
@@ -3382,7 +3382,7 @@ void Hash::HashDigest(const FunctionCallbackInfo<Value>& args) {
 
 
 SignBase::Error SignBase::Init(const char* sign_type) {
-  CHECK_EQ(mdctx_, nullptr);
+  CHECK_NULL(mdctx_);
   // Historically, "dss1" and "DSS1" were DSA aliases for SHA-1
   // exposed through the public API.
   if (strcmp(sign_type, "dss1") == 0 ||
@@ -4237,7 +4237,7 @@ void DiffieHellman::SetKey(const v8::FunctionCallbackInfo<v8::Value>& args,
   BIGNUM* num =
       BN_bin2bn(reinterpret_cast<unsigned char*>(Buffer::Data(args[0])),
                 Buffer::Length(args[0]), nullptr);
-  CHECK_NE(num, nullptr);
+  CHECK_NOT_NULL(num);
   CHECK_EQ(1, set_field(dh->dh_.get(), num));
 }
 
@@ -4495,7 +4495,7 @@ void ECDH::SetPrivateKey(const FunctionCallbackInfo<Value>& args) {
   USE(&mark_pop_error_on_return);
 
   const BIGNUM* priv_key = EC_KEY_get0_private_key(ecdh->key_.get());
-  CHECK_NE(priv_key, nullptr);
+  CHECK_NOT_NULL(priv_key);
 
   ECPointPointer pub(EC_POINT_new(ecdh->group_));
   CHECK(pub);
@@ -5006,7 +5006,7 @@ void VerifySpkac(const FunctionCallbackInfo<Value>& args) {
     return args.GetReturnValue().Set(verify_result);
 
   char* data = Buffer::Data(args[0]);
-  CHECK_NE(data, nullptr);
+  CHECK_NOT_NULL(data);
 
   verify_result = VerifySpkac(data, length);
 
@@ -5051,7 +5051,7 @@ void ExportPublicKey(const FunctionCallbackInfo<Value>& args) {
     return args.GetReturnValue().SetEmptyString();
 
   char* data = Buffer::Data(args[0]);
-  CHECK_NE(data, nullptr);
+  CHECK_NOT_NULL(data);
 
   size_t pkey_size;
   char* pkey = ExportPublicKey(data, length, &pkey_size);
@@ -5083,7 +5083,7 @@ void ExportChallenge(const FunctionCallbackInfo<Value>& args) {
     return args.GetReturnValue().SetEmptyString();
 
   char* data = Buffer::Data(args[0]);
-  CHECK_NE(data, nullptr);
+  CHECK_NOT_NULL(data);
 
   OpenSSLBuffer cert = ExportChallenge(data, len);
   if (!cert)

src/node_crypto.h

@@ -630,7 +630,7 @@ class ECDH : public BaseObject {
         key_(std::move(key)),
         group_(EC_KEY_get0_group(key_.get())) {
     MakeWeak();
-    CHECK_NE(group_, nullptr);
+    CHECK_NOT_NULL(group_);
   }
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);

src/node_crypto_bio.cc

@@ -518,7 +518,7 @@ NodeBIO::~NodeBIO() {
 
 
 NodeBIO* NodeBIO::FromBIO(BIO* bio) {
-  CHECK_NE(BIO_get_data(bio), nullptr);
+  CHECK_NOT_NULL(BIO_get_data(bio));
   return static_cast<NodeBIO*>(BIO_get_data(bio));
 }
 

src/node_crypto_clienthello-inl.h

@@ -65,7 +65,7 @@ inline void ClientHelloParser::Start(ClientHelloParser::OnHelloCb onhello_cb,
     return;
   Reset();
 
-  CHECK_NE(onhello_cb, nullptr);
+  CHECK_NOT_NULL(onhello_cb);
 
   state_ = kWaiting;
   onhello_cb_ = onhello_cb;