fixup! fs: move getValidMode to c++ for better performance

src/node_file.cc

@@ -66,6 +66,7 @@ using v8::HandleScope;
 using v8::Int32;
 using v8::Integer;
 using v8::Isolate;
+using v8::Just;
 using v8::JustVoid;
 using v8::Local;
 using v8::Maybe;
@@ -89,6 +90,10 @@ constexpr char kPathSeparator = '/';
 const char* const kPathSeparator = "\\/";
 #endif
 
+#ifdef _WIN32
+#include "uv.h"
+#endif
+
 // The access modes can be any of F_OK, R_OK, W_OK or X_OK. Some might not be
 // available on specific systems. They can be used in combination as well
 // (F_OK | R_OK | W_OK | X_OK).
@@ -872,41 +877,39 @@ void FromNamespacedPath(std::string* path) {
 #endif
 }
 
-static inline int GetValidMode(Environment* env,
-                               Local<Value> mode_v,
-                               std::string_view type) {
+static inline Maybe<int> GetValidMode(Environment* env,
+                                      Local<Value> mode_v,
+                                      uv_fs_type type) {
   if (!mode_v->IsInt32() && !mode_v->IsNullOrUndefined()) {
     THROW_ERR_INVALID_ARG_TYPE(env, "mode must be int32 or null/undefined");
-    return -1;
+    return Nothing<int>();
   }
 
   int min = kMinimumAccessMode;
   int max = kMaximumAccessMode;
   int def = F_OK;
 
-  if (type == "copyFile") {
+  CHECK(type == UV_FS_ACCESS || type == UV_FS_COPYFILE);
+
+  if (type == UV_FS_COPYFILE) {
     min = kMinimumCopyMode;
     max = kMaximumCopyMode;
     def = mode_v->IsNullOrUndefined() ? kDefaultCopyMode
                                       : mode_v.As<Int32>()->Value();
-  } else if (type != "access") {
-    THROW_ERR_INVALID_ARG_TYPE(
-        env, "type must be equal to \"copyFile\" or \"access\"");
-    return -1;
   }
 
   if (mode_v->IsNullOrUndefined()) {
-    return def;
+    return Just(def);
   }
 
   const int mode = mode_v.As<Int32>()->Value();
   if (mode < min || mode > max) {
     THROW_ERR_OUT_OF_RANGE(
         env, "mode is out of range: >= %d && <= %d", min, max);
-    return -1;
+    return Nothing<int>();
   }
 
-  return mode;
+  return Just(mode);
 }
 
 void AfterMkdirp(uv_fs_t* req) {
@@ -1028,8 +1031,8 @@ void Access(const FunctionCallbackInfo<Value>& args) {
   const int argc = args.Length();
   CHECK_GE(argc, 2);
 
-  int mode = GetValidMode(env, args[1], "access");
-  if (mode == -1) return;
+  Maybe<int> mode = GetValidMode(env, args[1], UV_FS_ACCESS);
+  if (mode.IsNothing()) return;
 
   BufferValue path(isolate, args[0]);
   CHECK_NOT_NULL(*path);
@@ -1041,12 +1044,20 @@ void Access(const FunctionCallbackInfo<Value>& args) {
     CHECK_NOT_NULL(req_wrap_async);
     FS_ASYNC_TRACE_BEGIN1(
         UV_FS_ACCESS, req_wrap_async, "path", TRACE_STR_COPY(*path))
-    AsyncCall(env, req_wrap_async, args, "access", UTF8, AfterNoArgs,
-              uv_fs_access, *path, mode);
+    AsyncCall(env,
+              req_wrap_async,
+              args,
+              "access",
+              UTF8,
+              AfterNoArgs,
+              uv_fs_access,
+              *path,
+              mode.FromJust());
   } else {  // access(path, mode)
     FSReqWrapSync req_wrap_sync("access", *path);
     FS_SYNC_TRACE_BEGIN(access);
-    SyncCallAndThrowOnError(env, &req_wrap_sync, uv_fs_access, *path, mode);
+    SyncCallAndThrowOnError(
+        env, &req_wrap_sync, uv_fs_access, *path, mode.FromJust());
     FS_SYNC_TRACE_END(access);
   }
 }
@@ -2141,8 +2152,8 @@ static void CopyFile(const FunctionCallbackInfo<Value>& args) {
   const int argc = args.Length();
   CHECK_GE(argc, 3);
 
-  const int flags = GetValidMode(env, args[2], "copyFile");
-  if (flags == -1) return;
+  Maybe<int> flags = GetValidMode(env, args[2], UV_FS_COPYFILE);
+  if (flags.IsNothing()) return;
 
   BufferValue src(isolate, args[0]);
   CHECK_NOT_NULL(*src);
@@ -2162,14 +2173,23 @@ static void CopyFile(const FunctionCallbackInfo<Value>& args) {
                           TRACE_STR_COPY(*src),
                           "dest",
                           TRACE_STR_COPY(*dest))
-    AsyncDestCall(env, req_wrap_async, args, "copyfile",
-                  *dest, dest.length(), UTF8, AfterNoArgs,
-                  uv_fs_copyfile, *src, *dest, flags);
+    AsyncDestCall(env,
+                  req_wrap_async,
+                  args,
+                  "copyfile",
+                  *dest,
+                  dest.length(),
+                  UTF8,
+                  AfterNoArgs,
+                  uv_fs_copyfile,
+                  *src,
+                  *dest,
+                  flags.FromJust());
   } else {  // copyFile(src, dest, flags)
     FSReqWrapSync req_wrap_sync("copyfile", *src, *dest);
     FS_SYNC_TRACE_BEGIN(copyfile);
     SyncCallAndThrowOnError(
-        env, &req_wrap_sync, uv_fs_copyfile, *src, *dest, flags);
+        env, &req_wrap_sync, uv_fs_copyfile, *src, *dest, flags.FromJust());
     FS_SYNC_TRACE_END(copyfile);
   }
 }

src/node_file.h

@@ -52,6 +52,8 @@ enum class FsStatFsOffset {
   kFsStatFsFieldsNumber
 };
 
+enum class ModeOpType { access = 0, copyFile };
+
 constexpr size_t kFsStatFsBufferLength =
     static_cast<size_t>(FsStatFsOffset::kFsStatFsFieldsNumber);