fix: remove unnecessary static/inline keywords

f

Author: aminya

.github/workflows/CI.yml

@@ -139,7 +139,8 @@ jobs:
       - name: Build Native Windows 32
         if: ${{ matrix.os == 'windows-2019' && matrix.node_arch == 'ia32' }}
         run:
-          node ./node_modules/@aminya/cmake-ts/build/main.js named-configs windows-x86
+          node ./node_modules/@aminya/cmake-ts/build/main.js named-configs
+          windows-x86
 
       - name: Use Node 20
         if: ${{ !matrix.docker }}

package.json

@@ -107,7 +107,7 @@
     "test.electron.renderer": "run-s build && electron-mocha --renderer",
     "lint-test.eslint": "eslint ./**/*.{ts,tsx,js,jsx,cjs,mjs,json,yaml} --no-error-on-unmatched-pattern --cache --cache-location ./.cache/eslint/",
     "lint.eslint": "pnpm run lint-test.eslint --fix",
-    "lint.clang-tidy": "git ls-files --exclude-standard | grep -E '\\.(cpp|hpp|c|cc|cxx|hxx|h|ixx)$' | xargs -n 1 -P $(nproc) clang-tidy --fix ",
+    "lint.clang-tidy": "git ls-files --exclude-standard | grep -E '\\.(cpp|hpp|c|cc|cxx|hxx|h|ixx)$' | xargs -n 1 -P $(nproc) clang-tidy",
     "lint": "run-p format lint.eslint format",
     "lint-test": "run-s lint-test.eslint",
     "bench": "node --expose-gc test/bench",

src/module.cc

@@ -10,7 +10,7 @@
 #include "util/error.h"
 
 namespace zmq {
-static inline Napi::String Version(const Napi::Env& env) {
+Napi::String Version(const Napi::Env& env) {
     int32_t major = 0;
     int32_t minor = 0;
     int32_t patch = 0;
@@ -21,7 +21,7 @@ static inline Napi::String Version(const Napi::Env& env) {
             + std::to_string(patch));
 }
 
-static inline Napi::Object Capabilities(const Napi::Env& env) {
+Napi::Object Capabilities(const Napi::Env& env) {
     auto result = Napi::Object::New(env);
 
 #ifdef ZMQ_HAS_CAPABILITIES
@@ -57,7 +57,7 @@ static inline Napi::Object Capabilities(const Napi::Env& env) {
     return result;
 }
 
-static inline Napi::Value CurveKeyPair(const Napi::CallbackInfo& info) {
+Napi::Value CurveKeyPair(const Napi::CallbackInfo& info) {
     char public_key[41];
     char secret_key[41];
     if (zmq_curve_keypair(public_key, secret_key) < 0) {

src/observer.cc

@@ -12,7 +12,7 @@
 #include "util/take.h"
 
 namespace zmq {
-static constexpr const char* EventName(uint32_t val) {
+constexpr const char* EventName(uint32_t val) {
     switch (val) {
     case ZMQ_EVENT_CONNECTED:
         return "connect";
@@ -76,7 +76,7 @@ static constexpr const char* EventName(uint32_t val) {
 }
 
 #ifdef ZMQ_EVENT_HANDSHAKE_FAILED_AUTH
-static constexpr const char* AuthError(uint32_t val) {
+constexpr const char* AuthError(uint32_t val) {
     switch (val) {
     case 300:
         return "Temporary error";
@@ -92,7 +92,7 @@ static constexpr const char* AuthError(uint32_t val) {
 #endif
 
 #ifdef ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL
-static inline std::pair<const char*, const char*> ProtoError(uint32_t val) {
+std::pair<const char*, const char*> ProtoError(uint32_t val) {
 #define PROTO_ERROR_CASE(_prefix, _err)                                                  \
     case ZMQ_PROTOCOL_ERROR_##_prefix##_##_err:                                          \
         return std::make_pair(#_prefix " protocol error", "ERR_" #_prefix "_" #_err);
@@ -157,20 +157,20 @@ Observer::Observer(const Napi::CallbackInfo& info)
         return;
     }
 
-    uv_os_sock_t fd = 0;
-    size_t length = sizeof(fd);
+    uv_os_sock_t file_descriptor = 0;
+    size_t length = sizeof(file_descriptor);
 
     if (zmq_connect(socket, address.c_str()) < 0) {
         ErrnoException(Env(), zmq_errno()).ThrowAsJavaScriptException();
         goto error;
     }
 
-    if (zmq_getsockopt(socket, ZMQ_FD, &fd, &length) < 0) {
+    if (zmq_getsockopt(socket, ZMQ_FD, &file_descriptor, &length) < 0) {
         ErrnoException(Env(), zmq_errno()).ThrowAsJavaScriptException();
         goto error;
     }
 
-    if (poller.Initialize(Env(), fd) < 0) {
+    if (poller.Initialize(Env(), file_descriptor) < 0) {
         ErrnoException(Env(), errno).ThrowAsJavaScriptException();
         goto error;
     }

src/socket.cc

@@ -101,7 +101,7 @@ Socket::Socket(const Napi::CallbackInfo& info)
         return;
     }
 
-    uv_os_sock_t fd = 0;
+    uv_os_sock_t file_descriptor = 0;
     std::function<void()> const finalize = nullptr;
 
 #ifdef ZMQ_THREAD_SAFE
@@ -153,14 +153,14 @@ Socket::Socket(const Napi::CallbackInfo& info)
         goto error;
 #endif
     } else {
-        size_t length = sizeof(fd);
-        if (zmq_getsockopt(socket, ZMQ_FD, &fd, &length) < 0) {
+        size_t length = sizeof(file_descriptor);
+        if (zmq_getsockopt(socket, ZMQ_FD, &file_descriptor, &length) < 0) {
             ErrnoException(Env(), zmq_errno()).ThrowAsJavaScriptException();
             goto error;
         }
     }
 
-    if (poller.Initialize(Env(), fd, finalize) < 0) {
+    if (poller.Initialize(Env(), file_descriptor, finalize) < 0) {
         ErrnoException(Env(), errno).ThrowAsJavaScriptException();
         goto error;
     }

src/util/electron_helper.h

@@ -8,13 +8,13 @@ namespace zmq {
 static bool hasRun = false;
 static bool hasElectronMemoryCageCache = false;
 
-static inline std::string first_component(std::string const& value) {
+inline std::string first_component(std::string const& value) {
     std::string::size_type const pos = value.find('.');
     return pos == std::string::npos ? value : value.substr(0, pos);
 }
 
 /* Check if runtime is Electron. */
-static inline bool IsElectron(const Napi::Env& env) {
+inline bool IsElectron(const Napi::Env& env) {
     auto global = env.Global();
     auto isElectron = global.Get("process")
                           .As<Napi::Object>()
@@ -24,7 +24,7 @@ static inline bool IsElectron(const Napi::Env& env) {
     return isElectron;
 }
 
-static inline bool hasElectronMemoryCage(const Napi::Env& env) {
+inline bool hasElectronMemoryCage(const Napi::Env& env) {
     if (!hasRun) {
         if (IsElectron(env)) {
             auto electronVers = env.Global()

src/util/error.h

@@ -12,22 +12,22 @@ static constexpr const char* ErrnoMessage(int32_t errorno);
 static constexpr const char* ErrnoCode(int32_t errorno);
 
 /* Generates a process warning message. */
-static inline void Warn(const Napi::Env& env, const std::string& msg) {
+inline void Warn(const Napi::Env& env, const std::string& msg) {
     auto global = env.Global();
-    auto fn =
+    auto emitWarning =
         global.Get("process").As<Napi::Object>().Get("emitWarning").As<Napi::Function>();
-    fn.Call({Napi::String::New(env, msg)});
+    emitWarning.Call({Napi::String::New(env, msg)});
 }
 
-static inline Napi::Error StatusException(
+inline Napi::Error StatusException(
     const Napi::Env& env, const std::string& msg, uint32_t status) {
     Napi::HandleScope const scope(env);
     auto exception = Napi::Error::New(env, msg);
     exception.Set("status", Napi::Number::New(env, status));
     return exception;
 }
 
-static inline Napi::Error CodedException(
+inline Napi::Error CodedException(
     const Napi::Env& env, const std::string& msg, const std::string& code) {
     Napi::HandleScope const scope(env);
     auto exception = Napi::Error::New(env, msg);
@@ -36,7 +36,7 @@ static inline Napi::Error CodedException(
 }
 
 /* This mostly duplicates node::ErrnoException, but it is not public. */
-static inline Napi::Error ErrnoException(
+inline Napi::Error ErrnoException(
     const Napi::Env& env, int32_t error, const char* message = nullptr) {
     Napi::HandleScope const scope(env);
     auto exception =
@@ -46,7 +46,7 @@ static inline Napi::Error ErrnoException(
     return exception;
 }
 
-static inline Napi::Error ErrnoException(
+inline Napi::Error ErrnoException(
     const Napi::Env& env, int32_t error, const std::string& address) {
     auto exception = ErrnoException(env, error, nullptr);
     exception.Set("address", Napi::String::New(env, address));

src/util/object.h

@@ -4,14 +4,14 @@
 
 namespace zmq {
 /* Seals an object to prevent setting incorrect options. */
-static inline void Seal(Napi::Object object) {
+inline void Seal(Napi::Object object) {
     auto global = object.Env().Global();
     auto seal = global.Get("Object").As<Napi::Object>().Get("seal").As<Napi::Function>();
     seal.Call({object});
 }
 
 /* Assign all properties in the given options object. */
-static inline void Assign(Napi::Object object, Napi::Object options) {
+inline void Assign(Napi::Object object, Napi::Object options) {
     auto global = object.Env().Global();
     auto assign =
         global.Get("Object").As<Napi::Object>().Get("assign").As<Napi::Function>();

src/util/uvdelayed.h

@@ -46,7 +46,7 @@ class UvDelayed {
 
 /* This is similar to JS setImmediate(). */
 template <typename C>
-static inline void UvScheduleDelayed(const Napi::Env& env, C callback) {
+inline void UvScheduleDelayed(const Napi::Env& env, C callback) {
     auto immediate = new UvDelayed<C>(env, std::move(callback));
     return immediate->Schedule();
 }

src/util/uvwork.h

@@ -41,7 +41,7 @@ class UvWork {
 };
 
 template <typename E, typename C>
-static inline int32_t UvQueue(const Napi::Env& env, E execute, C complete) {
+inline int32_t UvQueue(const Napi::Env& env, E execute, C complete) {
     auto* loop = UvLoop(env);
     auto work = new UvWork<E, C>(std::move(execute), std::move(complete));
     return work->Schedule(loop);