src: avoid implicit type conversions (take 2)

This fixes more C4244 MSVC warnings in the code base. Refs: #37149 PR-URL: #37334 Reviewed-By: James M Snell <jasnell@gmail.com>
nodejs · targos · Mar 3, 2021 · Feb 14, 2021 · Feb 9, 2021 · Jan 28, 2021
commit c75f5f372db052cd8a190645b169b640c845bec5
diff --git a/src/base64-inl.h b/src/base64-inl.h
@@ -30,21 +30,17 @@ bool base64_decode_group_slow(char* const dst, const size_t dstlen,
                               size_t* const i, size_t* const k) {
   uint8_t hi;
   uint8_t lo;
-#define V(expr)                                                               \
-  for (;;) {                                                                  \
-    const uint8_t c = src[*i];                                                \
-    lo = unbase64(c);                                                         \
-    *i += 1;                                                                  \
-    if (lo < 64)                                                              \
-      break;  /* Legal character. */                                          \
-    if (c == '=' || *i >= srclen)                                             \
-      return false;  /* Stop decoding. */                                     \
-  }                                                                           \
-  expr;                                                                       \
-  if (*i >= srclen)                                                           \
-    return false;                                                             \
-  if (*k >= dstlen)                                                           \
-    return false;                                                             \
+#define V(expr)                                                                \
+  for (;;) {                                                                   \
+    const uint8_t c = static_cast<uint8_t>(src[*i]);                           \
+    lo = unbase64(c);                                                          \
+    *i += 1;                                                                   \
+    if (lo < 64) break;                         /* Legal character. */         \
+    if (c == '=' || *i >= srclen) return false; /* Stop decoding. */           \
+  }                                                                            \
+  expr;                                                                        \
+  if (*i >= srclen) return false;                                              \
+  if (*k >= dstlen) return false;                                              \
   hi = lo;
   V(/* Nothing. */);
   V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
@@ -66,10 +62,10 @@ size_t base64_decode_fast(char* const dst, const size_t dstlen,
   size_t k = 0;
   while (i < max_i && k < max_k) {
     const unsigned char txt[] = {
-      static_cast<unsigned char>(unbase64(src[i + 0])),
-      static_cast<unsigned char>(unbase64(src[i + 1])),
-      static_cast<unsigned char>(unbase64(src[i + 2])),
-      static_cast<unsigned char>(unbase64(src[i + 3])),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
     };
 
     const uint32_t v = ReadUint32BE(txt);

diff --git a/src/crypto/crypto_dsa.cc b/src/crypto/crypto_dsa.cc
@@ -146,14 +146,18 @@ Maybe<bool> GetDsaKeyDetail(
   size_t modulus_length = BN_num_bytes(p) * CHAR_BIT;
   size_t divisor_length = BN_num_bytes(q) * CHAR_BIT;
 
-  if (target->Set(
-          env->context(),
-          env->modulus_length_string(),
-          Number::New(env->isolate(), modulus_length)).IsNothing() ||
-      target->Set(
-          env->context(),
-          env->divisor_length_string(),
-          Number::New(env->isolate(), divisor_length)).IsNothing()) {
+  if (target
+          ->Set(
+              env->context(),
+              env->modulus_length_string(),
+              Number::New(env->isolate(), static_cast<double>(modulus_length)))
+          .IsNothing() ||
+      target
+          ->Set(
+              env->context(),
+              env->divisor_length_string(),
+              Number::New(env->isolate(), static_cast<double>(divisor_length)))
+          .IsNothing()) {
     return Nothing<bool>();
   }
 

diff --git a/src/crypto/crypto_keygen.cc b/src/crypto/crypto_keygen.cc
@@ -66,7 +66,8 @@ Maybe<bool> SecretKeyGenTraits::AdditionalConfig(
     SecretKeyGenConfig* params) {
   Environment* env = Environment::GetCurrent(args);
   CHECK(args[*offset]->IsUint32());
-  params->length = std::trunc(args[*offset].As<Uint32>()->Value() / CHAR_BIT);
+  params->length = static_cast<size_t>(
+      std::trunc(args[*offset].As<Uint32>()->Value() / CHAR_BIT));
   if (params->length > INT_MAX) {
     const std::string msg{
       SPrintF("length must be less than or equal to %s bits",

diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
@@ -529,10 +529,9 @@ Maybe<bool> GetSecretKeyDetail(
   // converted to bits.
 
   size_t length = key->GetSymmetricKeySize() * CHAR_BIT;
-  return target->Set(
-      env->context(),
-      env->length_string(),
-      Number::New(env->isolate(), length));
+  return target->Set(env->context(),
+                     env->length_string(),
+                     Number::New(env->isolate(), static_cast<double>(length)));
 }
 
 Maybe<bool> GetAsymmetricKeyDetail(

diff --git a/src/crypto/crypto_rsa.cc b/src/crypto/crypto_rsa.cc
@@ -532,10 +532,12 @@ Maybe<bool> GetRsaKeyDetail(
 
   size_t modulus_length = BN_num_bytes(n) * CHAR_BIT;
 
-  if (target->Set(
-          env->context(),
-          env->modulus_length_string(),
-          Number::New(env->isolate(), modulus_length)).IsNothing()) {
+  if (target
+          ->Set(
+              env->context(),
+              env->modulus_length_string(),
+              Number::New(env->isolate(), static_cast<double>(modulus_length)))
+          .IsNothing()) {
     return Nothing<bool>();
   }
 

diff --git a/src/inspector/worker_inspector.cc b/src/inspector/worker_inspector.cc
@@ -11,7 +11,7 @@ namespace {
 class WorkerStartedRequest : public Request {
  public:
   WorkerStartedRequest(
-      int id,
+      uint64_t id,
       const std::string& url,
       std::shared_ptr<node::inspector::MainThreadHandle> worker_thread,
       bool waiting)
@@ -28,7 +28,7 @@ class WorkerStartedRequest : public Request {
     return "Worker " + std::to_string(id);
   }
 
-  int id_;
+  uint64_t id_;
   WorkerInfo info_;
   bool waiting_;
 };
@@ -42,22 +42,25 @@ void Report(const std::unique_ptr<WorkerDelegate>& delegate,
 
 class WorkerFinishedRequest : public Request {
  public:
-  explicit WorkerFinishedRequest(int worker_id) : worker_id_(worker_id) {}
+  explicit WorkerFinishedRequest(uint64_t worker_id) : worker_id_(worker_id) {}
 
   void Call(MainThreadInterface* thread) override {
     thread->inspector_agent()->GetWorkerManager()->WorkerFinished(worker_id_);
   }
 
  private:
-  int worker_id_;
+  uint64_t worker_id_;
 };
 }  // namespace
 
-
 ParentInspectorHandle::ParentInspectorHandle(
-    int id, const std::string& url,
-    std::shared_ptr<MainThreadHandle> parent_thread, bool wait_for_connect)
-    : id_(id), url_(url), parent_thread_(parent_thread),
+    uint64_t id,
+    const std::string& url,
+    std::shared_ptr<MainThreadHandle> parent_thread,
+    bool wait_for_connect)
+    : id_(id),
+      url_(url),
+      parent_thread_(parent_thread),
       wait_(wait_for_connect) {}
 
 ParentInspectorHandle::~ParentInspectorHandle() {
@@ -78,11 +81,11 @@ std::unique_ptr<inspector::InspectorSession> ParentInspectorHandle::Connect(
   return parent_thread_->Connect(std::move(delegate), prevent_shutdown);
 }
 
-void WorkerManager::WorkerFinished(int session_id) {
+void WorkerManager::WorkerFinished(uint64_t session_id) {
   children_.erase(session_id);
 }
 
-void WorkerManager::WorkerStarted(int session_id,
+void WorkerManager::WorkerStarted(uint64_t session_id,
                                   const WorkerInfo& info,
                                   bool waiting) {
   if (info.worker_thread->Expired())
@@ -93,8 +96,8 @@ void WorkerManager::WorkerStarted(int session_id,
   }
 }
 
-std::unique_ptr<ParentInspectorHandle>
-WorkerManager::NewParentHandle(int thread_id, const std::string& url) {
+std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
+    uint64_t thread_id, const std::string& url) {
   bool wait = !delegates_waiting_on_start_.empty();
   return std::make_unique<ParentInspectorHandle>(thread_id, url, thread_, wait);
 }

diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
@@ -53,12 +53,13 @@ struct WorkerInfo {
 
 class ParentInspectorHandle {
  public:
-  ParentInspectorHandle(int id, const std::string& url,
+  ParentInspectorHandle(uint64_t id,
+                        const std::string& url,
                         std::shared_ptr<MainThreadHandle> parent_thread,
                         bool wait_for_connect);
   ~ParentInspectorHandle();
   std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
-      int thread_id, const std::string& url) {
+      uint64_t thread_id, const std::string& url) {
     return std::make_unique<ParentInspectorHandle>(thread_id,
                                                    url,
                                                    parent_thread_,
@@ -75,7 +76,7 @@ class ParentInspectorHandle {
       bool prevent_shutdown);
 
  private:
-  int id_;
+  uint64_t id_;
   std::string url_;
   std::shared_ptr<MainThreadHandle> parent_thread_;
   bool wait_;
@@ -87,9 +88,9 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
                          : thread_(thread) {}
 
   std::unique_ptr<ParentInspectorHandle> NewParentHandle(
-      int thread_id, const std::string& url);
-  void WorkerStarted(int session_id, const WorkerInfo& info, bool waiting);
-  void WorkerFinished(int session_id);
+      uint64_t thread_id, const std::string& url);
+  void WorkerStarted(uint64_t session_id, const WorkerInfo& info, bool waiting);
+  void WorkerFinished(uint64_t session_id);
   std::unique_ptr<WorkerManagerEventHandle> SetAutoAttach(
       std::unique_ptr<WorkerDelegate> attach_delegate);
   void SetWaitOnStartForDelegate(int id, bool wait);
@@ -100,7 +101,7 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
 
  private:
   std::shared_ptr<MainThreadHandle> thread_;
-  std::unordered_map<int, WorkerInfo> children_;
+  std::unordered_map<uint64_t, WorkerInfo> children_;
   std::unordered_map<int, std::unique_ptr<WorkerDelegate>> delegates_;
   // If any one needs it, workers stop for all
   std::unordered_set<int> delegates_waiting_on_start_;

diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
@@ -527,7 +527,7 @@ class NodeInspectorClient : public V8InspectorClient {
         timers_.emplace(std::piecewise_construct, std::make_tuple(data),
                         std::make_tuple(env_, [=]() { callback(data); }));
     CHECK(result.second);
-    uint64_t interval = 1000 * interval_s;
+    uint64_t interval = static_cast<uint64_t>(1000 * interval_s);
     result.first->second.Update(interval, interval);
   }
 
@@ -917,7 +917,7 @@ void Agent::SetParentHandle(
 }
 
 std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
-    int thread_id, const std::string& url) {
+    uint64_t thread_id, const std::string& url) {
   if (!parent_handle_) {
     return client_->getWorkerManager()->NewParentHandle(thread_id, url);
   } else {

diff --git a/src/inspector_agent.h b/src/inspector_agent.h
@@ -84,7 +84,7 @@ class Agent {
 
   void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
   std::unique_ptr<ParentInspectorHandle> GetParentHandle(
-      int thread_id, const std::string& url);
+      uint64_t thread_id, const std::string& url);
 
   // Called to create inspector sessions that can be used from the same thread.
   // The inspector responds by using the delegate to send messages back.

diff --git a/src/node_serdes.cc b/src/node_serdes.cc
@@ -444,7 +444,7 @@ void DeserializerContext::ReadRawBytes(
   CHECK_GE(position, ctx->data_);
   CHECK_LE(position + length, ctx->data_ + ctx->length_);
 
-  const uint32_t offset = position - ctx->data_;
+  const uint32_t offset = static_cast<uint32_t>(position - ctx->data_);
   CHECK_EQ(ctx->data_ + offset, position);
 
   args.GetReturnValue().Set(offset);

diff --git a/src/node_url.cc b/src/node_url.cc
@@ -896,7 +896,7 @@ void URLHost::ParseIPv6Host(const char* input, size_t length) {
   }
 
   if (compress_pointer != nullptr) {
-    unsigned swaps = piece_pointer - compress_pointer;
+    int64_t swaps = piece_pointer - compress_pointer;
     piece_pointer = buffer_end - 1;
     while (piece_pointer != &value_.ipv6[0] && swaps > 0) {
       uint16_t temp = *piece_pointer;
@@ -963,7 +963,7 @@ void URLHost::ParseIPv4Host(const char* input, size_t length, bool* is_ipv4) {
 
   while (pointer <= end) {
     const char ch = pointer < end ? pointer[0] : kEOL;
-    int remaining = end - pointer - 1;
+    int64_t remaining = end - pointer - 1;
     if (ch == '.' || ch == kEOL) {
       if (++parts > static_cast<int>(arraysize(numbers)))
         return;
@@ -996,10 +996,11 @@ void URLHost::ParseIPv4Host(const char* input, size_t length, bool* is_ipv4) {
   }
 
   type_ = HostType::H_IPV4;
-  val = numbers[parts - 1];
+  val = static_cast<uint32_t>(numbers[parts - 1]);
   for (int n = 0; n < parts - 1; n++) {
     double b = 3 - n;
-    val += numbers[n] * pow(256, b);
+    val +=
+        static_cast<uint32_t>(numbers[n]) * static_cast<uint32_t>(pow(256, b));
   }
 
   value_.ipv4 = val;

diff --git a/src/node_wasi.cc b/src/node_wasi.cc
@@ -279,7 +279,8 @@ void WASI::ArgsGet(const FunctionCallbackInfo<Value>& args) {
 
   if (err == UVWASI_ESUCCESS) {
     for (size_t i = 0; i < wasi->uvw_.argc; i++) {
-      uint32_t offset = argv_buf_offset + (argv[i] - argv[0]);
+      uint32_t offset =
+          static_cast<uint32_t>(argv_buf_offset + (argv[i] - argv[0]));
       uvwasi_serdes_write_uint32_t(memory,
                                    argv_offset +
                                    (i * UVWASI_SERDES_SIZE_uint32_t),
@@ -410,7 +411,8 @@ void WASI::EnvironGet(const FunctionCallbackInfo<Value>& args) {
 
   if (err == UVWASI_ESUCCESS) {
     for (size_t i = 0; i < wasi->uvw_.envc; i++) {
-      uint32_t offset = environ_buf_offset + (environment[i] - environment[0]);
+      uint32_t offset = static_cast<uint32_t>(
+          environ_buf_offset + (environment[i] - environment[0]));
 
       uvwasi_serdes_write_uint32_t(memory,
                                    environ_offset +

diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
@@ -153,7 +153,7 @@ class SignalWrap : public HandleWrap {
 
 void DecreaseSignalHandlerCount(int signum) {
   Mutex::ScopedLock lock(handled_signals_mutex);
-  int new_handler_count = --handled_signals[signum];
+  int64_t new_handler_count = --handled_signals[signum];
   CHECK_GE(new_handler_count, 0);
   if (new_handler_count == 0)
     handled_signals.erase(signum);

diff --git a/src/stream_base.cc b/src/stream_base.cc
@@ -338,7 +338,7 @@ MaybeLocal<Value> StreamBase::CallJSOnreadMethod(ssize_t nread,
     }
   }
 
-  env->stream_base_state()[kReadBytesOrError] = nread;
+  env->stream_base_state()[kReadBytesOrError] = static_cast<int32_t>(nread);
   env->stream_base_state()[kArrayBufferOffset] = offset;
 
   Local<Value> argv[] = {

diff --git a/src/string_bytes.cc b/src/string_bytes.cc
@@ -250,8 +250,8 @@ static size_t hex_decode(char* buf,
                          const size_t srcLen) {
   size_t i;
   for (i = 0; i < len && i * 2 + 1 < srcLen; ++i) {
-    unsigned a = unhex(src[i * 2 + 0]);
-    unsigned b = unhex(src[i * 2 + 1]);
+    unsigned a = unhex(static_cast<uint8_t>(src[i * 2 + 0]));
+    unsigned b = unhex(static_cast<uint8_t>(src[i * 2 + 1]));
     if (!~a || !~b)
       return i;
     buf[i] = (a << 4) | b;

diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
@@ -531,7 +531,7 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
     wrap->current_send_has_callback_ =
         sendto ? args[5]->IsTrue() : args[3]->IsTrue();
 
-    err = wrap->Send(*bufs, count, addr);
+    err = static_cast<int>(wrap->Send(*bufs, count, addr));
 
     wrap->current_send_req_wrap_.Clear();
     wrap->current_send_has_callback_ = false;
@@ -705,11 +705,10 @@ void UDPWrap::OnRecv(ssize_t nread,
   Context::Scope context_scope(env->context());
 
   Local<Value> argv[] = {
-    Integer::New(env->isolate(), nread),
-    object(),
-    Undefined(env->isolate()),
-    Undefined(env->isolate())
-  };
+      Integer::New(env->isolate(), static_cast<int32_t>(nread)),
+      object(),
+      Undefined(env->isolate()),
+      Undefined(env->isolate())};
 
   if (nread < 0) {
     MakeCallback(env->onmessage_string(), arraysize(argv), argv);