src: clean up argument assertions in node_file.cc

- Cache `args.Length()`
- Use `value.As<T>()` to cast the arguments

PR-URL: #18192
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

src/node_file.cc

@@ -87,6 +87,7 @@ using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
+using v8::Int32;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
@@ -351,14 +352,15 @@ inline FSReqWrap* AsyncCall(Environment* env,
 // Template counterpart of SYNC_CALL, except that it only puts
 // the error number and the syscall in the context instead of
 // creating an error in the C++ land.
+// ctx must be checked using value->IsObject() before being passed.
 template <typename Func, typename... Args>
 inline int SyncCall(Environment* env, Local<Value> ctx, fs_req_wrap* req_wrap,
     const char* syscall, Func fn, Args... args) {
   env->PrintSyncTrace();
   int err = fn(env->event_loop(), &(req_wrap->req), args..., nullptr);
   if (err < 0) {
     Local<Context> context = env->context();
-    Local<Object> ctx_obj = ctx->ToObject(context).ToLocalChecked();
+    Local<Object> ctx_obj = ctx.As<Object>();
     Isolate *isolate = env->isolate();
     ctx_obj->Set(context,
              env->errno_string(),
@@ -391,19 +393,22 @@ inline int SyncCall(Environment* env, Local<Value> ctx, fs_req_wrap* req_wrap,
 void Access(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args.GetIsolate());
   HandleScope scope(env->isolate());
-  Local<Context> context = env->context();
-  CHECK_GE(args.Length(), 2);
+
+  const int argc = args.Length();
+  CHECK_GE(argc, 2);
+
   CHECK(args[1]->IsInt32());
+  int mode = args[1].As<Int32>()->Value();
 
   BufferValue path(env->isolate(), args[0]);
-  int mode = static_cast<int>(args[1]->Int32Value(context).FromJust());
+  CHECK_NE(*path, nullptr);
 
   if (args[2]->IsObject()) {  // access(path, mode, req)
-    CHECK_EQ(args.Length(), 3);
+    CHECK_EQ(argc, 3);
     AsyncCall(env, args, "access", UTF8, AfterNoArgs,
               uv_fs_access, *path, mode);
   } else {  // access(path, mode, undefined, ctx)
-    CHECK_EQ(args.Length(), 4);
+    CHECK_EQ(argc, 4);
     fs_req_wrap req_wrap;
     SyncCall(env, args[3], &req_wrap, "access", uv_fs_access, *path, mode);
   }
@@ -412,20 +417,19 @@ void Access(const FunctionCallbackInfo<Value>& args) {
 
 void Close(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
 
-  int length = args.Length();
-  CHECK_GE(length, 2);
-  CHECK(args[0]->IsInt32());
+  const int argc = args.Length();
+  CHECK_GE(argc, 2);
 
-  int fd = static_cast<int>(args[0]->Int32Value(context).FromJust());
+  CHECK(args[0]->IsInt32());
+  int fd = args[0].As<Int32>()->Value();
 
   if (args[1]->IsObject()) {  // close(fd, req)
-    CHECK_EQ(args.Length(), 2);
+    CHECK_EQ(argc, 2);
     AsyncCall(env, args, "close", UTF8, AfterNoArgs,
               uv_fs_close, fd);
   } else {  // close(fd, undefined, ctx)
-    CHECK_EQ(args.Length(), 3);
+    CHECK_EQ(argc, 3);
     fs_req_wrap req_wrap;
     SyncCall(env, args[2], &req_wrap, "close", uv_fs_close, fd);
   }
@@ -519,17 +523,18 @@ static void InternalModuleStat(const FunctionCallbackInfo<Value>& args) {
 static void Stat(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
-  CHECK_GE(args.Length(), 1);
+  const int argc = args.Length();
+  CHECK_GE(argc, 1);
 
   BufferValue path(env->isolate(), args[0]);
   CHECK_NE(*path, nullptr);
 
   if (args[1]->IsObject()) {  // stat(path, req)
-    CHECK_EQ(args.Length(), 2);
+    CHECK_EQ(argc, 2);
     AsyncCall(env, args, "stat", UTF8, AfterStat,
               uv_fs_stat, *path);
   } else {  // stat(path, undefined, ctx)
-    CHECK_EQ(args.Length(), 3);
+    CHECK_EQ(argc, 3);
     fs_req_wrap req_wrap;
     int err = SyncCall(env, args[2], &req_wrap, "stat", uv_fs_stat, *path);
     if (err == 0) {
@@ -542,17 +547,18 @@ static void Stat(const FunctionCallbackInfo<Value>& args) {
 static void LStat(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
-  CHECK_GE(args.Length(), 1);
+  const int argc = args.Length();
+  CHECK_GE(argc, 1);
 
   BufferValue path(env->isolate(), args[0]);
   CHECK_NE(*path, nullptr);
 
   if (args[1]->IsObject()) {  // lstat(path, req)
-    CHECK_EQ(args.Length(), 2);
+    CHECK_EQ(argc, 2);
     AsyncCall(env, args, "lstat", UTF8, AfterStat,
               uv_fs_lstat, *path);
   } else {  // lstat(path, undefined, ctx)
-    CHECK_EQ(args.Length(), 3);
+    CHECK_EQ(argc, 3);
     fs_req_wrap req_wrap;
     int err = SyncCall(env, args[2], &req_wrap, "lstat", uv_fs_lstat, *path);
     if (err == 0) {
@@ -564,18 +570,19 @@ static void LStat(const FunctionCallbackInfo<Value>& args) {
 
 static void FStat(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
-  Local<Context> context = env->context();
 
-  CHECK(args[0]->IsInt32());
+  const int argc = args.Length();
+  CHECK_GE(argc, 1);
 
-  int fd = static_cast<int>(args[0]->Int32Value(context).FromJust());
+  CHECK(args[0]->IsInt32());
+  int fd = args[0].As<Int32>()->Value();
 
   if (args[1]->IsObject()) {  // fstat(fd, req)
-    CHECK_EQ(args.Length(), 2);
+    CHECK_EQ(argc, 2);
     AsyncCall(env, args, "fstat", UTF8, AfterStat,
               uv_fs_fstat, fd);
   } else {  // fstat(fd, undefined, ctx)
-    CHECK_EQ(args.Length(), 3);
+    CHECK_EQ(argc, 3);
     fs_req_wrap req_wrap;
     int err = SyncCall(env, args[2], &req_wrap, "fstat", uv_fs_fstat, fd);
     if (err == 0) {