function stat(path, options, callback) {// ...// FSReqCallback是来源于c++层的一个classconst req = new FSReqCallback(options.bigint);req.oncomplete = callback;// 这里的第三个参数是一个Object 回调函数仅作为一个oncomplete属性
  binding.stat(pathModule.toNamespacedPath(path), options.bigint, req);
}

static void Stat(const FunctionCallbackInfo<Value>& args) {Environment* env = Environment::GetCurrent(args);// 检测参数数量是否大于2const int argc = args.Length();CHECK_GE(argc, 2);// 检测path参数合法性BufferValue path(env->isolate(), args[0]);CHECK_NOT_NULL(*path);// 检测是否传了use_bigintbool use_bigint = args[1]->IsTrue();// 在同步调用stat的情况下 这个class为空指针// if、else后面有同步/异步调用时参数情况FSReqBase* req_wrap_async = GetReqWrap(env, args[2], use_bigint);if (req_wrap_async != nullptr) {  // stat(path, use_bigint, req)AsyncCall(env, req_wrap_async, args, "stat", UTF8, AfterStat,uv_fs_stat, *path);} else {  // stat(path, use_bigint, undefined, ctx)// 同步情况...
  }
}

AsyncCall(env, req_wrap_async, args, "stat", UTF8, AfterStat,uv_fs_stat, *path);

// Func类型为普通函数
// Args为路径path
template <typename Func, typename... Args>
inline FSReqBase* AsyncCall(Environment* env,FSReqBase* req_wrap,const FunctionCallbackInfo<Value>& args,const char* syscall, enum encoding enc,uv_fs_cb after, Func fn, Args... fn_args) {return AsyncDestCall(env, req_wrap, args, syscall, nullptr, 0, enc, after, fn, fn_args...);
}template <typename Func, typename... Args>
inline FSReqBase* AsyncDestCall(Environment* env,FSReqBase* req_wrap,const FunctionCallbackInfo<Value>& args,const char* syscall, const char* dest, size_t len,enum encoding enc, uv_fs_cb after, Func fn, Args... fn_args) {// 异步调用这个类不能为空指针
  CHECK_NOT_NULL(req_wrap);// 依次调用包装类的方法req_wrap->Init(syscall, dest, len, enc);int err = req_wrap->Dispatch(fn, fn_args..., after);if (err < 0) {// 出现error的情况 不用看...} else {req_wrap->SetReturnValue(args);}return req_wrap;
}

FSReqBase* req_wrap_async = GetReqWrap(env, args[2], use_bigint);
inline FSReqBase* GetReqWrap(Environment* env, Local<Value> value, bool use_bigint = false) {if (value->IsObject()) {return Unwrap<FSReqBase>(value.As<Object>());} else if (value->StrictEquals(env->fs_use_promises_symbol())) {// Promise情况...
  }return nullptr;
}

template <class T>
static inline T* Unwrap(v8::Local<v8::Object> handle) {// ...// 这里是类型强转return static_cast<T*>(wrap);
}class FSReqBase : public ReqWrap<uv_fs_t> {public:// ...void Init(const char* syscall, const char* data, size_t len, enum encoding encoding) {}
}template <typename T>
class ReqWrap : public AsyncWrap, public ReqWrapBase {public:// ...inline int Dispatch(LibuvFunction fn, Args... args);private:// ...
};

req_wrap->Init(syscall, dest, len, enc);
int err = req_wrap->Dispatch(fn, fn_args..., after);

void Init(const char* syscall, const char* data, size_t len, enum encoding encoding) {syscall_ = syscall;encoding_ = encoding;if (data != nullptr) {// ...
  }
}

template <typename T>
template <typename LibuvFunction, typename... Args>
int ReqWrap<T>::Dispatch(LibuvFunction fn, Args... args) {Dispatched();// This expands as://// int err = fn(env()->event_loop(), req(), arg1, arg2, Wrapper, arg3, ...)//              ^                                       ^        ^//              |                                       |        |//              \-- Omitted if `fn` has no              |        |//                  first `uv_loop_t*` argument         |        |//                                                      |        |//        A function callback whose first argument      |        |//        matches the libuv request type is replaced ---/        |//        by the `Wrapper` method defined above                  |//                                                               |//               Other (non-function) arguments are passed  -----///               through verbatimint err = CallLibuvFunction<T, LibuvFunction>::Call(fn, env()->event_loop(), req(), MakeLibuvRequestCallback<T, Args>::For(this, args)...);if (err >= 0)env()->IncreaseWaitingRequestCounter();return err;
}