From 71328538ffca44b0c8454857ff89ccecb0c984e7 Mon Sep 17 00:00:00 2001 From: Timothy Gu Date: Fri, 22 Jun 2018 01:25:12 -0400 Subject: [PATCH 1/5] src: start annotating native code side effect Refs: https://github.com/nodejs/node/issues/20977 --- src/cares_wrap.cc | 10 +++++++--- src/env-inl.h | 33 +++++++++++++++++++++---------- src/env.h | 16 +++++++++++---- src/inspector_js_api.cc | 7 +++++-- src/module_wrap.cc | 13 +++++++++---- src/node.cc | 27 ++++++++++++++++++-------- src/node_buffer.cc | 43 +++++++++++++++++++++++++++-------------- src/node_crypto.cc | 19 ++++++++++++------ src/node_types.cc | 7 +++++-- src/node_url.cc | 13 +++++++++---- src/node_util.cc | 22 ++++++++++++++------- src/node_v8.cc | 4 +++- src/stream_base-inl.h | 33 ++++++++++++++++--------------- src/tty_wrap.cc | 13 +++++++++---- 14 files changed, 175 insertions(+), 85 deletions(-) diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc index 05ef2b7e12090e..9deb57a5f61979 100644 --- a/src/cares_wrap.cc +++ b/src/cares_wrap.cc @@ -65,6 +65,7 @@ using v8::Integer; using v8::Local; using v8::Null; using v8::Object; +using v8::SideEffectType; using v8::String; using v8::Value; @@ -2107,8 +2108,10 @@ void Initialize(Local target, env->SetMethod(target, "getaddrinfo", GetAddrInfo); env->SetMethod(target, "getnameinfo", GetNameInfo); - env->SetMethod(target, "isIPv6", IsIPv6); - env->SetMethod(target, "canonicalizeIP", CanonicalizeIP); + env->SetMethod(target, "isIPv6", IsIPv6, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "canonicalizeIP", CanonicalizeIP, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "strerror", StrError); @@ -2165,7 +2168,8 @@ void Initialize(Local target, env->SetProtoMethod(channel_wrap, "querySoa", Query); env->SetProtoMethod(channel_wrap, "getHostByAddr", Query); - env->SetProtoMethod(channel_wrap, "getServers", GetServers); + env->SetProtoMethod(channel_wrap, "getServers", GetServers, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(channel_wrap, "setServers", SetServers); env->SetProtoMethod(channel_wrap, "cancel", Cancel); diff --git a/src/env-inl.h b/src/env-inl.h index bbb80c6f7ae916..962de2d86b320c 100644 --- a/src/env-inl.h +++ b/src/env-inl.h @@ -675,17 +675,24 @@ inline void Environment::ThrowUVException(int errorno, inline v8::Local Environment::NewFunctionTemplate(v8::FunctionCallback callback, v8::Local signature, - v8::ConstructorBehavior behavior) { + v8::ConstructorBehavior behavior, + v8::SideEffectType side_effect_type) { v8::Local external = as_external(); return v8::FunctionTemplate::New(isolate(), callback, external, - signature, 0, behavior); + signature, 0, behavior, side_effect_type); } inline void Environment::SetMethod(v8::Local that, const char* name, - v8::FunctionCallback callback) { + v8::FunctionCallback callback, + v8::SideEffectType side_effect_type) { v8::Local function = - NewFunctionTemplate(callback)->GetFunction(); + NewFunctionTemplate(callback, + v8::Local(), + // TODO(TimothyGu): Investigate if SetMethod is ever + // used for constructors. + v8::ConstructorBehavior::kAllow, + side_effect_type)->GetFunction(); // kInternalized strings are created in the old space. const v8::NewStringType type = v8::NewStringType::kInternalized; v8::Local name_string = @@ -696,10 +703,12 @@ inline void Environment::SetMethod(v8::Local that, inline void Environment::SetProtoMethod(v8::Local that, const char* name, - v8::FunctionCallback callback) { + v8::FunctionCallback callback, + v8::SideEffectType side_effect_type) { v8::Local signature = v8::Signature::New(isolate(), that); v8::Local t = - NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow); + NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow, + side_effect_type); // kInternalized strings are created in the old space. const v8::NewStringType type = v8::NewStringType::kInternalized; v8::Local name_string = @@ -708,10 +717,14 @@ inline void Environment::SetProtoMethod(v8::Local that, t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility. } -inline void Environment::SetTemplateMethod(v8::Local that, - const char* name, - v8::FunctionCallback callback) { - v8::Local t = NewFunctionTemplate(callback); +inline void Environment::SetTemplateMethod( + v8::Local that, + const char* name, + v8::FunctionCallback callback, + v8::SideEffectType side_effect_type) { + v8::Local t = + NewFunctionTemplate(callback, v8::Local(), + v8::ConstructorBehavior::kAllow, side_effect_type); // kInternalized strings are created in the old space. const v8::NewStringType type = v8::NewStringType::kInternalized; v8::Local name_string = diff --git a/src/env.h b/src/env.h index 786f0846f4ae1a..d132fdf43c9e3c 100644 --- a/src/env.h +++ b/src/env.h @@ -752,18 +752,26 @@ class Environment { v8::Local signature = v8::Local(), v8::ConstructorBehavior behavior = - v8::ConstructorBehavior::kAllow); + v8::ConstructorBehavior::kAllow, + v8::SideEffectType side_effect_type = + v8::SideEffectType::kHasSideEffect); // Convenience methods for NewFunctionTemplate(). inline void SetMethod(v8::Local that, const char* name, - v8::FunctionCallback callback); + v8::FunctionCallback callback, + v8::SideEffectType side_effect_type = + v8::SideEffectType::kHasSideEffect); inline void SetProtoMethod(v8::Local that, const char* name, - v8::FunctionCallback callback); + v8::FunctionCallback callback, + v8::SideEffectType side_effect_type = + v8::SideEffectType::kHasSideEffect); inline void SetTemplateMethod(v8::Local that, const char* name, - v8::FunctionCallback callback); + v8::FunctionCallback callback, + v8::SideEffectType side_effect_type = + v8::SideEffectType::kHasSideEffect); void BeforeExit(void (*cb)(void* arg), void* arg); void RunBeforeExitCallbacks(); diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc index 802029ac4f2e5a..4a70b76f0db952 100644 --- a/src/inspector_js_api.cc +++ b/src/inspector_js_api.cc @@ -20,6 +20,7 @@ using v8::Local; using v8::MaybeLocal; using v8::NewStringType; using v8::Object; +using v8::SideEffectType; using v8::String; using v8::Value; @@ -289,7 +290,8 @@ void Initialize(Local target, Local unused, if (agent->IsWaitingForConnect()) env->SetMethod(target, "callAndPauseOnStart", CallAndPauseOnStart); env->SetMethod(target, "open", Open); - env->SetMethod(target, "url", Url); + env->SetMethod(target, "url", Url, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "asyncTaskScheduled", AsyncTaskScheduledWrapper); env->SetMethod(target, "asyncTaskCanceled", @@ -300,7 +302,8 @@ void Initialize(Local target, Local unused, InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>); env->SetMethod(target, "registerAsyncHook", RegisterAsyncHookWrapper); - env->SetMethod(target, "isEnabled", IsEnabled); + env->SetMethod(target, "isEnabled", IsEnabled, + SideEffectType::kHasNoSideEffect); auto conn_str = FIXED_ONE_BYTE_STRING(env->isolate(), "Connection"); Local tmpl = diff --git a/src/module_wrap.cc b/src/module_wrap.cc index 05daa2bb85ebe0..a970902d8f0c9a 100644 --- a/src/module_wrap.cc +++ b/src/module_wrap.cc @@ -37,6 +37,7 @@ using v8::Object; using v8::Promise; using v8::ScriptCompiler; using v8::ScriptOrigin; +using v8::SideEffectType; using v8::String; using v8::TryCatch; using v8::Undefined; @@ -789,11 +790,15 @@ void ModuleWrap::Initialize(Local target, env->SetProtoMethod(tpl, "link", Link); env->SetProtoMethod(tpl, "instantiate", Instantiate); env->SetProtoMethod(tpl, "evaluate", Evaluate); - env->SetProtoMethod(tpl, "namespace", Namespace); - env->SetProtoMethod(tpl, "getStatus", GetStatus); - env->SetProtoMethod(tpl, "getError", GetError); + env->SetProtoMethod(tpl, "namespace", Namespace, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(tpl, "getStatus", GetStatus, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(tpl, "getError", GetError, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(tpl, "getStaticDependencySpecifiers", - GetStaticDependencySpecifiers); + GetStaticDependencySpecifiers, + SideEffectType::kHasNoSideEffect); target->Set(FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"), tpl->GetFunction()); env->SetMethod(target, "resolve", Resolve); diff --git a/src/node.cc b/src/node.cc index 6cf5f2ad84b1db..8d257ce53a5939 100644 --- a/src/node.cc +++ b/src/node.cc @@ -159,6 +159,7 @@ using v8::Promise; using v8::PropertyCallbackInfo; using v8::ScriptOrigin; using v8::SealHandleScope; +using v8::SideEffectType; using v8::String; using v8::TryCatch; using v8::Undefined; @@ -1947,7 +1948,10 @@ void SetupProcessObject(Environment* env, title_string, ProcessTitleGetter, env->is_main_thread() ? ProcessTitleSetter : nullptr, - env->as_external()).FromJust()); + env->as_external(), + v8::DEFAULT, + v8::None, + SideEffectType::kHasNoSideEffect).FromJust()); // process.version READONLY_PROPERTY(process, @@ -2252,17 +2256,24 @@ void SetupProcessObject(Environment* env, env->SetMethod(process, "_getActiveHandles", GetActiveHandles); env->SetMethod(process, "_kill", Kill); - env->SetMethod(process, "cwd", Cwd); + env->SetMethod(process, "cwd", Cwd, + SideEffectType::kHasNoSideEffect); env->SetMethod(process, "dlopen", DLOpen); env->SetMethod(process, "reallyExit", Exit); - env->SetMethod(process, "uptime", Uptime); + env->SetMethod(process, "uptime", Uptime, + SideEffectType::kHasNoSideEffect); #if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__) - env->SetMethod(process, "getuid", GetUid); - env->SetMethod(process, "geteuid", GetEUid); - env->SetMethod(process, "getgid", GetGid); - env->SetMethod(process, "getegid", GetEGid); - env->SetMethod(process, "getgroups", GetGroups); + env->SetMethod(process, "getuid", GetUid, + SideEffectType::kHasNoSideEffect); + env->SetMethod(process, "geteuid", GetEUid, + SideEffectType::kHasNoSideEffect); + env->SetMethod(process, "getgid", GetGid, + SideEffectType::kHasNoSideEffect); + env->SetMethod(process, "getegid", GetEGid, + SideEffectType::kHasNoSideEffect); + env->SetMethod(process, "getgroups", GetGroups, + SideEffectType::kHasNoSideEffect); #endif // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__) } diff --git a/src/node_buffer.cc b/src/node_buffer.cc index 9465145ac37eb9..4be3d34822c36f 100644 --- a/src/node_buffer.cc +++ b/src/node_buffer.cc @@ -82,6 +82,7 @@ using v8::Local; using v8::Maybe; using v8::MaybeLocal; using v8::Object; +using v8::SideEffectType; using v8::String; using v8::Uint32Array; using v8::Uint8Array; @@ -1083,12 +1084,18 @@ void SetupBufferJS(const FunctionCallbackInfo& args) { Local proto = args[0].As(); env->set_buffer_prototype_object(proto); - env->SetMethod(proto, "asciiSlice", StringSlice); - env->SetMethod(proto, "base64Slice", StringSlice); - env->SetMethod(proto, "latin1Slice", StringSlice); - env->SetMethod(proto, "hexSlice", StringSlice); - env->SetMethod(proto, "ucs2Slice", StringSlice); - env->SetMethod(proto, "utf8Slice", StringSlice); + env->SetMethod(proto, "asciiSlice", StringSlice, + SideEffectType::kHasNoSideEffect); + env->SetMethod(proto, "base64Slice", StringSlice, + SideEffectType::kHasNoSideEffect); + env->SetMethod(proto, "latin1Slice", StringSlice, + SideEffectType::kHasNoSideEffect); + env->SetMethod(proto, "hexSlice", StringSlice, + SideEffectType::kHasNoSideEffect); + env->SetMethod(proto, "ucs2Slice", StringSlice, + SideEffectType::kHasNoSideEffect); + env->SetMethod(proto, "utf8Slice", StringSlice, + SideEffectType::kHasNoSideEffect); env->SetMethod(proto, "asciiWrite", StringWrite); env->SetMethod(proto, "base64Write", StringWrite); @@ -1116,22 +1123,30 @@ void Initialize(Local target, Environment* env = Environment::GetCurrent(context); env->SetMethod(target, "setupBufferJS", SetupBufferJS); - env->SetMethod(target, "createFromString", CreateFromString); + env->SetMethod(target, "createFromString", CreateFromString, + SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "byteLengthUtf8", ByteLengthUtf8); + env->SetMethod(target, "byteLengthUtf8", ByteLengthUtf8, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "copy", Copy); - env->SetMethod(target, "compare", Compare); - env->SetMethod(target, "compareOffset", CompareOffset); + env->SetMethod(target, "compare", Compare, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "compareOffset", CompareOffset, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "fill", Fill); - env->SetMethod(target, "indexOfBuffer", IndexOfBuffer); - env->SetMethod(target, "indexOfNumber", IndexOfNumber); - env->SetMethod(target, "indexOfString", IndexOfString); + env->SetMethod(target, "indexOfBuffer", IndexOfBuffer, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "indexOfNumber", IndexOfNumber, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "indexOfString", IndexOfString, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "swap16", Swap16); env->SetMethod(target, "swap32", Swap32); env->SetMethod(target, "swap64", Swap64); - env->SetMethod(target, "encodeUtf8String", EncodeUtf8String); + env->SetMethod(target, "encodeUtf8String", EncodeUtf8String, + SideEffectType::kHasNoSideEffect); target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"), diff --git a/src/node_crypto.cc b/src/node_crypto.cc index 8b152e65c3335c..e484ad33c9447a 100644 --- a/src/node_crypto.cc +++ b/src/node_crypto.cc @@ -84,6 +84,7 @@ using v8::Null; using v8::Object; using v8::PropertyAttribute; using v8::ReadOnly; +using v8::SideEffectType; using v8::Signature; using v8::String; using v8::Uint32; @@ -5193,12 +5194,18 @@ void Initialize(Local target, #endif env->SetMethod(target, "pbkdf2", PBKDF2); - env->SetMethod(target, "randomBytes", RandomBytes); - env->SetMethod(target, "timingSafeEqual", TimingSafeEqual); - env->SetMethod(target, "getSSLCiphers", GetSSLCiphers); - env->SetMethod(target, "getCiphers", GetCiphers); - env->SetMethod(target, "getHashes", GetHashes); - env->SetMethod(target, "getCurves", GetCurves); + env->SetMethod(target, "randomBytes", RandomBytes, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "timingSafeEqual", TimingSafeEqual, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "getSSLCiphers", GetSSLCiphers, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "getCiphers", GetCiphers, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "getHashes", GetHashes, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "getCurves", GetCurves, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "publicEncrypt", PublicKeyCipher::Cipher target, #define V(type) env->SetMethod(target, \ "is" #type, \ - Is##type); + Is##type, \ + SideEffectType::kHasNoSideEffect); VALUE_METHOD_MAP(V) #undef V - env->SetMethod(target, "isAnyArrayBuffer", IsAnyArrayBuffer); + env->SetMethod(target, "isAnyArrayBuffer", IsAnyArrayBuffer, + SideEffectType::kHasNoSideEffect); } } // anonymous namespace diff --git a/src/node_url.cc b/src/node_url.cc index 82c093d516bc4a..e34274f8738cde 100644 --- a/src/node_url.cc +++ b/src/node_url.cc @@ -22,6 +22,7 @@ using v8::Local; using v8::MaybeLocal; using v8::Null; using v8::Object; +using v8::SideEffectType; using v8::String; using v8::TryCatch; using v8::Undefined; @@ -2334,10 +2335,14 @@ static void Initialize(Local target, void* priv) { Environment* env = Environment::GetCurrent(context); env->SetMethod(target, "parse", Parse); - env->SetMethod(target, "encodeAuth", EncodeAuthSet); - env->SetMethod(target, "toUSVString", ToUSVString); - env->SetMethod(target, "domainToASCII", DomainToASCII); - env->SetMethod(target, "domainToUnicode", DomainToUnicode); + env->SetMethod(target, "encodeAuth", EncodeAuthSet, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "toUSVString", ToUSVString, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "domainToASCII", DomainToASCII, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "domainToUnicode", DomainToUnicode, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "setURLConstructor", SetURLConstructor); #define XX(name, _) NODE_DEFINE_CONSTANT(target, name); diff --git a/src/node_util.cc b/src/node_util.cc index 2db68586459ab2..b9946652fe248a 100644 --- a/src/node_util.cc +++ b/src/node_util.cc @@ -14,6 +14,7 @@ using v8::Object; using v8::Private; using v8::Promise; using v8::Proxy; +using v8::SideEffectType; using v8::String; using v8::Value; @@ -212,18 +213,25 @@ void Initialize(Local target, V(kRejected); #undef V - env->SetMethod(target, "getHiddenValue", GetHiddenValue); + env->SetMethod(target, "getHiddenValue", GetHiddenValue, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "setHiddenValue", SetHiddenValue); - env->SetMethod(target, "getPromiseDetails", GetPromiseDetails); - env->SetMethod(target, "getProxyDetails", GetProxyDetails); - env->SetMethod(target, "safeToString", SafeToString); - env->SetMethod(target, "previewEntries", PreviewEntries); + env->SetMethod(target, "getPromiseDetails", GetPromiseDetails, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "getProxyDetails", GetProxyDetails, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "safeToString", SafeToString, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "previewEntries", PreviewEntries, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "startSigintWatchdog", StartSigintWatchdog); env->SetMethod(target, "stopSigintWatchdog", StopSigintWatchdog); - env->SetMethod(target, "watchdogHasPendingSigint", WatchdogHasPendingSigint); + env->SetMethod(target, "watchdogHasPendingSigint", WatchdogHasPendingSigint, + SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "createPromise", CreatePromise); + env->SetMethod(target, "createPromise", CreatePromise, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "promiseResolve", PromiseResolve); env->SetMethod(target, "promiseReject", PromiseReject); diff --git a/src/node_v8.cc b/src/node_v8.cc index d546eeba93f4d9..3e6597ee6041f5 100644 --- a/src/node_v8.cc +++ b/src/node_v8.cc @@ -39,6 +39,7 @@ using v8::Local; using v8::NewStringType; using v8::Object; using v8::ScriptCompiler; +using v8::SideEffectType; using v8::String; using v8::Uint32; using v8::V8; @@ -122,7 +123,8 @@ void Initialize(Local target, Local context) { Environment* env = Environment::GetCurrent(context); - env->SetMethod(target, "cachedDataVersionTag", CachedDataVersionTag); + env->SetMethod(target, "cachedDataVersionTag", CachedDataVersionTag, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "updateHeapStatisticsArrayBuffer", diff --git a/src/stream_base-inl.h b/src/stream_base-inl.h index 4509825a60d184..bd451031737be1 100644 --- a/src/stream_base-inl.h +++ b/src/stream_base-inl.h @@ -277,29 +277,30 @@ void StreamBase::AddMethods(Environment* env, Local signature = Signature::New(env->isolate(), t); + // TODO(TimothyGu): None of these should have ConstructorBehavior::kAllow. Local get_fd_templ = - FunctionTemplate::New(env->isolate(), - GetFD, - env->as_external(), - signature); + env->NewFunctionTemplate(GetFD, + signature, + v8::ConstructorBehavior::kAllow, + v8::SideEffectType::kHasNoSideEffect); Local get_external_templ = - FunctionTemplate::New(env->isolate(), - GetExternal, - env->as_external(), - signature); + env->NewFunctionTemplate(GetExternal, + signature, + v8::ConstructorBehavior::kAllow, + v8::SideEffectType::kHasNoSideEffect); Local get_bytes_read_templ = - FunctionTemplate::New(env->isolate(), - GetBytesRead, - env->as_external(), - signature); + env->NewFunctionTemplate(GetBytesRead, + signature, + v8::ConstructorBehavior::kAllow, + v8::SideEffectType::kHasNoSideEffect); Local get_bytes_written_templ = - FunctionTemplate::New(env->isolate(), - GetBytesWritten, - env->as_external(), - signature); + env->NewFunctionTemplate(GetBytesWritten, + signature, + v8::ConstructorBehavior::kAllow, + v8::SideEffectType::kHasNoSideEffect); t->PrototypeTemplate()->SetAccessorProperty(env->fd_string(), get_fd_templ, diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc index 175b32879bbb83..319793bf7abb86 100644 --- a/src/tty_wrap.cc +++ b/src/tty_wrap.cc @@ -38,6 +38,7 @@ using v8::FunctionTemplate; using v8::Integer; using v8::Local; using v8::Object; +using v8::SideEffectType; using v8::String; using v8::Value; @@ -58,15 +59,19 @@ void TTYWrap::Initialize(Local target, env->SetProtoMethod(t, "close", HandleWrap::Close); env->SetProtoMethod(t, "unref", HandleWrap::Unref); env->SetProtoMethod(t, "ref", HandleWrap::Ref); - env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef); + env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef, + SideEffectType::kHasNoSideEffect); LibuvStreamWrap::AddMethods(env, t); - env->SetProtoMethod(t, "getWindowSize", TTYWrap::GetWindowSize); + env->SetProtoMethod(t, "getWindowSize", TTYWrap::GetWindowSize, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "setRawMode", SetRawMode); - env->SetMethod(target, "isTTY", IsTTY); - env->SetMethod(target, "guessHandleType", GuessHandleType); + env->SetMethod(target, "isTTY", IsTTY, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "guessHandleType", GuessHandleType, + SideEffectType::kHasNoSideEffect); target->Set(ttyString, t->GetFunction()); env->set_tty_constructor_template(t); From c5f4cb577f5f8abb15e4fd461c140ec47f773723 Mon Sep 17 00:00:00 2001 From: Timothy Gu Date: Fri, 22 Jun 2018 08:56:24 -0400 Subject: [PATCH 2/5] fixup! src: start annotating native code side effect crypto --- src/node_crypto.cc | 107 ++++++++++++++++++++++++++++++--------------- 1 file changed, 72 insertions(+), 35 deletions(-) diff --git a/src/node_crypto.cc b/src/node_crypto.cc index e484ad33c9447a..c40b8a720d2368 100644 --- a/src/node_crypto.cc +++ b/src/node_crypto.cc @@ -63,6 +63,7 @@ namespace crypto { using v8::Array; using v8::Boolean; +using v8::ConstructorBehavior; using v8::Context; using v8::DontDelete; using v8::EscapableHandleScope; @@ -347,12 +348,15 @@ void SecureContext::Initialize(Environment* env, Local target) { #ifndef OPENSSL_NO_ENGINE env->SetProtoMethod(t, "setClientCertEngine", SetClientCertEngine); #endif // !OPENSSL_NO_ENGINE - env->SetProtoMethod(t, "getTicketKeys", GetTicketKeys); + env->SetProtoMethod(t, "getTicketKeys", GetTicketKeys, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "setTicketKeys", SetTicketKeys); env->SetProtoMethod(t, "setFreeListLength", SetFreeListLength); env->SetProtoMethod(t, "enableTicketKeyCallback", EnableTicketKeyCallback); - env->SetProtoMethod(t, "getCertificate", GetCertificate); - env->SetProtoMethod(t, "getIssuer", GetCertificate); + env->SetProtoMethod(t, "getCertificate", GetCertificate, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getIssuer", GetCertificate, + SideEffectType::kHasNoSideEffect); t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyReturnIndex"), Integer::NewFromUnsigned(env->isolate(), kTicketKeyReturnIndex)); @@ -1368,32 +1372,44 @@ template void SSLWrap::AddMethods(Environment* env, Local t) { HandleScope scope(env->isolate()); - env->SetProtoMethod(t, "getPeerCertificate", GetPeerCertificate); - env->SetProtoMethod(t, "getFinished", GetFinished); - env->SetProtoMethod(t, "getPeerFinished", GetPeerFinished); - env->SetProtoMethod(t, "getSession", GetSession); + env->SetProtoMethod(t, "getPeerCertificate", GetPeerCertificate, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getFinished", GetFinished, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getPeerFinished", GetPeerFinished, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getSession", GetSession, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "setSession", SetSession); env->SetProtoMethod(t, "loadSession", LoadSession); - env->SetProtoMethod(t, "isSessionReused", IsSessionReused); - env->SetProtoMethod(t, "isInitFinished", IsInitFinished); - env->SetProtoMethod(t, "verifyError", VerifyError); - env->SetProtoMethod(t, "getCurrentCipher", GetCurrentCipher); + env->SetProtoMethod(t, "isSessionReused", IsSessionReused, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "isInitFinished", IsInitFinished, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "verifyError", VerifyError, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getCurrentCipher", GetCurrentCipher, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "endParser", EndParser); env->SetProtoMethod(t, "certCbDone", CertCbDone); env->SetProtoMethod(t, "renegotiate", Renegotiate); env->SetProtoMethod(t, "shutdownSSL", Shutdown); - env->SetProtoMethod(t, "getTLSTicket", GetTLSTicket); + env->SetProtoMethod(t, "getTLSTicket", GetTLSTicket, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "newSessionDone", NewSessionDone); env->SetProtoMethod(t, "setOCSPResponse", SetOCSPResponse); env->SetProtoMethod(t, "requestOCSP", RequestOCSP); - env->SetProtoMethod(t, "getEphemeralKeyInfo", GetEphemeralKeyInfo); - env->SetProtoMethod(t, "getProtocol", GetProtocol); + env->SetProtoMethod(t, "getEphemeralKeyInfo", GetEphemeralKeyInfo, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getProtocol", GetProtocol, + SideEffectType::kHasNoSideEffect); #ifdef SSL_set_max_send_fragment env->SetProtoMethod(t, "setMaxSendFragment", SetMaxSendFragment); #endif // SSL_set_max_send_fragment - env->SetProtoMethod(t, "getALPNNegotiatedProtocol", GetALPNNegotiatedProto); + env->SetProtoMethod(t, "getALPNNegotiatedProtocol", GetALPNNegotiatedProto, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "setALPNProtocols", SetALPNProtocols); } @@ -2564,7 +2580,8 @@ void CipherBase::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "update", Update); env->SetProtoMethod(t, "final", Final); env->SetProtoMethod(t, "setAutoPadding", SetAutoPadding); - env->SetProtoMethod(t, "getAuthTag", GetAuthTag); + env->SetProtoMethod(t, "getAuthTag", GetAuthTag, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "setAuthTag", SetAuthTag); env->SetProtoMethod(t, "setAAD", SetAAD); @@ -3899,10 +3916,14 @@ void DiffieHellman::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "generateKeys", GenerateKeys); env->SetProtoMethod(t, "computeSecret", ComputeSecret); - env->SetProtoMethod(t, "getPrime", GetPrime); - env->SetProtoMethod(t, "getGenerator", GetGenerator); - env->SetProtoMethod(t, "getPublicKey", GetPublicKey); - env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey); + env->SetProtoMethod(t, "getPrime", GetPrime, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getGenerator", GetGenerator, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getPublicKey", GetPublicKey, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "setPublicKey", SetPublicKey); env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey); @@ -3910,7 +3931,10 @@ void DiffieHellman::Initialize(Environment* env, Local target) { FunctionTemplate::New(env->isolate(), DiffieHellman::VerifyErrorGetter, env->as_external(), - Signature::New(env->isolate(), t)); + Signature::New(env->isolate(), t), + // TODO(TimothyGu): should be deny + ConstructorBehavior::kAllow, + SideEffectType::kHasNoSideEffect); t->InstanceTemplate()->SetAccessorProperty( env->verify_error_string(), @@ -3926,16 +3950,23 @@ void DiffieHellman::Initialize(Environment* env, Local target) { env->SetProtoMethod(t2, "generateKeys", GenerateKeys); env->SetProtoMethod(t2, "computeSecret", ComputeSecret); - env->SetProtoMethod(t2, "getPrime", GetPrime); - env->SetProtoMethod(t2, "getGenerator", GetGenerator); - env->SetProtoMethod(t2, "getPublicKey", GetPublicKey); - env->SetProtoMethod(t2, "getPrivateKey", GetPrivateKey); + env->SetProtoMethod(t2, "getPrime", GetPrime, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t2, "getGenerator", GetGenerator, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t2, "getPublicKey", GetPublicKey, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t2, "getPrivateKey", GetPrivateKey, + SideEffectType::kHasNoSideEffect); Local verify_error_getter_templ2 = FunctionTemplate::New(env->isolate(), DiffieHellman::VerifyErrorGetter, env->as_external(), - Signature::New(env->isolate(), t2)); + Signature::New(env->isolate(), t2), + // TODO(TimothyGu): should be deny + ConstructorBehavior::kAllow, + SideEffectType::kHasNoSideEffect); t2->InstanceTemplate()->SetAccessorProperty( env->verify_error_string(), @@ -4287,8 +4318,10 @@ void ECDH::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "generateKeys", GenerateKeys); env->SetProtoMethod(t, "computeSecret", ComputeSecret); - env->SetProtoMethod(t, "getPublicKey", GetPublicKey); - env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey); + env->SetProtoMethod(t, "getPublicKey", GetPublicKey, + SideEffectType::kHasNoSideEffect); + env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey, + SideEffectType::kHasNoSideEffect); env->SetProtoMethod(t, "setPublicKey", SetPublicKey); env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey); @@ -5179,23 +5212,27 @@ void Initialize(Local target, Sign::Initialize(env, target); Verify::Initialize(env, target); - env->SetMethod(target, "certVerifySpkac", VerifySpkac); - env->SetMethod(target, "certExportPublicKey", ExportPublicKey); - env->SetMethod(target, "certExportChallenge", ExportChallenge); + env->SetMethod(target, "certVerifySpkac", VerifySpkac, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "certExportPublicKey", ExportPublicKey, + SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "certExportChallenge", ExportChallenge, + SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "ECDHConvertKey", ConvertKey); + env->SetMethod(target, "ECDHConvertKey", ConvertKey, + SideEffectType::kHasNoSideEffect); #ifndef OPENSSL_NO_ENGINE env->SetMethod(target, "setEngine", SetEngine); #endif // !OPENSSL_NO_ENGINE #ifdef NODE_FIPS_MODE - env->SetMethod(target, "getFipsCrypto", GetFipsCrypto); + env->SetMethod(target, "getFipsCrypto", GetFipsCrypto, + SideEffectType::kHasNoSideEffect); env->SetMethod(target, "setFipsCrypto", SetFipsCrypto); #endif env->SetMethod(target, "pbkdf2", PBKDF2); - env->SetMethod(target, "randomBytes", RandomBytes, - SideEffectType::kHasNoSideEffect); + env->SetMethod(target, "randomBytes", RandomBytes); env->SetMethod(target, "timingSafeEqual", TimingSafeEqual, SideEffectType::kHasNoSideEffect); env->SetMethod(target, "getSSLCiphers", GetSSLCiphers, From d418bb807d292bf0c98cff0319667d0a8b6bd7d5 Mon Sep 17 00:00:00 2001 From: Timothy Gu Date: Fri, 22 Jun 2018 19:58:50 -0400 Subject: [PATCH 3/5] fixup! fixup! src: start annotating native code side effect --- src/cares_wrap.cc | 10 ++-- src/env-inl.h | 66 ++++++++++++++++++++---- src/env.h | 26 ++++++---- src/inspector_js_api.cc | 7 +-- src/module_wrap.cc | 15 ++---- src/node.cc | 21 +++----- src/node_buffer.cc | 43 +++++----------- src/node_crypto.cc | 110 ++++++++++++++-------------------------- src/node_types.cc | 11 ++-- src/node_url.cc | 13 ++--- src/node_util.cc | 23 +++------ src/node_v8.cc | 4 +- src/tty_wrap.cc | 13 ++--- 13 files changed, 162 insertions(+), 200 deletions(-) diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc index 9deb57a5f61979..99f8779e1ab88f 100644 --- a/src/cares_wrap.cc +++ b/src/cares_wrap.cc @@ -65,7 +65,6 @@ using v8::Integer; using v8::Local; using v8::Null; using v8::Object; -using v8::SideEffectType; using v8::String; using v8::Value; @@ -2108,10 +2107,8 @@ void Initialize(Local target, env->SetMethod(target, "getaddrinfo", GetAddrInfo); env->SetMethod(target, "getnameinfo", GetNameInfo); - env->SetMethod(target, "isIPv6", IsIPv6, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "canonicalizeIP", CanonicalizeIP, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "isIPv6", IsIPv6); + env->SetSafeMethod(target, "canonicalizeIP", CanonicalizeIP); env->SetMethod(target, "strerror", StrError); @@ -2168,8 +2165,7 @@ void Initialize(Local target, env->SetProtoMethod(channel_wrap, "querySoa", Query); env->SetProtoMethod(channel_wrap, "getHostByAddr", Query); - env->SetProtoMethod(channel_wrap, "getServers", GetServers, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(channel_wrap, "getServers", GetServers); env->SetProtoMethod(channel_wrap, "setServers", SetServers); env->SetProtoMethod(channel_wrap, "cancel", Cancel); diff --git a/src/env-inl.h b/src/env-inl.h index 962de2d86b320c..487cd2544f787e 100644 --- a/src/env-inl.h +++ b/src/env-inl.h @@ -684,15 +684,32 @@ inline v8::Local inline void Environment::SetMethod(v8::Local that, const char* name, - v8::FunctionCallback callback, - v8::SideEffectType side_effect_type) { + v8::FunctionCallback callback) { v8::Local function = NewFunctionTemplate(callback, v8::Local(), // TODO(TimothyGu): Investigate if SetMethod is ever // used for constructors. v8::ConstructorBehavior::kAllow, - side_effect_type)->GetFunction(); + v8::SideEffectType::kHasSideEffect)->GetFunction(); + // kInternalized strings are created in the old space. + const v8::NewStringType type = v8::NewStringType::kInternalized; + v8::Local name_string = + v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked(); + that->Set(name_string, function); + function->SetName(name_string); // NODE_SET_METHOD() compatibility. +} + +inline void Environment::SetSafeMethod(v8::Local that, + const char* name, + v8::FunctionCallback callback) { + v8::Local function = + NewFunctionTemplate(callback, + v8::Local(), + // TODO(TimothyGu): Investigate if SetMethod is ever + // used for constructors. + v8::ConstructorBehavior::kAllow, + v8::SideEffectType::kHasNoSideEffect)->GetFunction(); // kInternalized strings are created in the old space. const v8::NewStringType type = v8::NewStringType::kInternalized; v8::Local name_string = @@ -703,12 +720,11 @@ inline void Environment::SetMethod(v8::Local that, inline void Environment::SetProtoMethod(v8::Local that, const char* name, - v8::FunctionCallback callback, - v8::SideEffectType side_effect_type) { + v8::FunctionCallback callback) { v8::Local signature = v8::Signature::New(isolate(), that); v8::Local t = NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow, - side_effect_type); + v8::SideEffectType::kHasSideEffect); // kInternalized strings are created in the old space. const v8::NewStringType type = v8::NewStringType::kInternalized; v8::Local name_string = @@ -717,14 +733,44 @@ inline void Environment::SetProtoMethod(v8::Local that, t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility. } -inline void Environment::SetTemplateMethod( +inline void Environment::SetSafeProtoMethod( + v8::Local that, const char* name, + v8::FunctionCallback callback) { + v8::Local signature = v8::Signature::New(isolate(), that); + v8::Local t = + NewFunctionTemplate(callback, signature, v8::ConstructorBehavior::kThrow, + v8::SideEffectType::kHasNoSideEffect); + // kInternalized strings are created in the old space. + const v8::NewStringType type = v8::NewStringType::kInternalized; + v8::Local name_string = + v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked(); + that->PrototypeTemplate()->Set(name_string, t); + t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility. +} + +inline void Environment::SetTemplateMethod(v8::Local that, + const char* name, + v8::FunctionCallback callback) { + v8::Local t = + NewFunctionTemplate(callback, v8::Local(), + v8::ConstructorBehavior::kAllow, + v8::SideEffectType::kHasSideEffect); + // kInternalized strings are created in the old space. + const v8::NewStringType type = v8::NewStringType::kInternalized; + v8::Local name_string = + v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked(); + that->Set(name_string, t); + t->SetClassName(name_string); // NODE_SET_METHOD() compatibility. +} + +inline void Environment::SetSafeTemplateMethod( v8::Local that, const char* name, - v8::FunctionCallback callback, - v8::SideEffectType side_effect_type) { + v8::FunctionCallback callback) { v8::Local t = NewFunctionTemplate(callback, v8::Local(), - v8::ConstructorBehavior::kAllow, side_effect_type); + v8::ConstructorBehavior::kAllow, + v8::SideEffectType::kHasNoSideEffect); // kInternalized strings are created in the old space. const v8::NewStringType type = v8::NewStringType::kInternalized; v8::Local name_string = diff --git a/src/env.h b/src/env.h index d132fdf43c9e3c..54ff66aade07a9 100644 --- a/src/env.h +++ b/src/env.h @@ -753,25 +753,31 @@ class Environment { v8::Local(), v8::ConstructorBehavior behavior = v8::ConstructorBehavior::kAllow, - v8::SideEffectType side_effect_type = + v8::SideEffectType side_effect = v8::SideEffectType::kHasSideEffect); // Convenience methods for NewFunctionTemplate(). inline void SetMethod(v8::Local that, const char* name, - v8::FunctionCallback callback, - v8::SideEffectType side_effect_type = - v8::SideEffectType::kHasSideEffect); + v8::FunctionCallback callback); + inline void SetProtoMethod(v8::Local that, const char* name, - v8::FunctionCallback callback, - v8::SideEffectType side_effect_type = - v8::SideEffectType::kHasSideEffect); + v8::FunctionCallback callback); inline void SetTemplateMethod(v8::Local that, const char* name, - v8::FunctionCallback callback, - v8::SideEffectType side_effect_type = - v8::SideEffectType::kHasSideEffect); + v8::FunctionCallback callback); + + // Safe variants denote the function has no side effects. + inline void SetSafeMethod(v8::Local that, + const char* name, + v8::FunctionCallback callback); + inline void SetSafeProtoMethod(v8::Local that, + const char* name, + v8::FunctionCallback callback); + inline void SetSafeTemplateMethod(v8::Local that, + const char* name, + v8::FunctionCallback callback); void BeforeExit(void (*cb)(void* arg), void* arg); void RunBeforeExitCallbacks(); diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc index 4a70b76f0db952..babc5706e03f93 100644 --- a/src/inspector_js_api.cc +++ b/src/inspector_js_api.cc @@ -20,7 +20,6 @@ using v8::Local; using v8::MaybeLocal; using v8::NewStringType; using v8::Object; -using v8::SideEffectType; using v8::String; using v8::Value; @@ -290,8 +289,7 @@ void Initialize(Local target, Local unused, if (agent->IsWaitingForConnect()) env->SetMethod(target, "callAndPauseOnStart", CallAndPauseOnStart); env->SetMethod(target, "open", Open); - env->SetMethod(target, "url", Url, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "url", Url); env->SetMethod(target, "asyncTaskScheduled", AsyncTaskScheduledWrapper); env->SetMethod(target, "asyncTaskCanceled", @@ -302,8 +300,7 @@ void Initialize(Local target, Local unused, InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>); env->SetMethod(target, "registerAsyncHook", RegisterAsyncHookWrapper); - env->SetMethod(target, "isEnabled", IsEnabled, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "isEnabled", IsEnabled); auto conn_str = FIXED_ONE_BYTE_STRING(env->isolate(), "Connection"); Local tmpl = diff --git a/src/module_wrap.cc b/src/module_wrap.cc index a970902d8f0c9a..e4da4813b0f2d8 100644 --- a/src/module_wrap.cc +++ b/src/module_wrap.cc @@ -37,7 +37,6 @@ using v8::Object; using v8::Promise; using v8::ScriptCompiler; using v8::ScriptOrigin; -using v8::SideEffectType; using v8::String; using v8::TryCatch; using v8::Undefined; @@ -790,15 +789,11 @@ void ModuleWrap::Initialize(Local target, env->SetProtoMethod(tpl, "link", Link); env->SetProtoMethod(tpl, "instantiate", Instantiate); env->SetProtoMethod(tpl, "evaluate", Evaluate); - env->SetProtoMethod(tpl, "namespace", Namespace, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(tpl, "getStatus", GetStatus, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(tpl, "getError", GetError, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(tpl, "getStaticDependencySpecifiers", - GetStaticDependencySpecifiers, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(tpl, "namespace", Namespace); + env->SetSafeProtoMethod(tpl, "getStatus", GetStatus); + env->SetSafeProtoMethod(tpl, "getError", GetError); + env->SetSafeProtoMethod(tpl, "getStaticDependencySpecifiers", + GetStaticDependencySpecifiers); target->Set(FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"), tpl->GetFunction()); env->SetMethod(target, "resolve", Resolve); diff --git a/src/node.cc b/src/node.cc index 8d257ce53a5939..9d68488ec6f151 100644 --- a/src/node.cc +++ b/src/node.cc @@ -2256,24 +2256,17 @@ void SetupProcessObject(Environment* env, env->SetMethod(process, "_getActiveHandles", GetActiveHandles); env->SetMethod(process, "_kill", Kill); - env->SetMethod(process, "cwd", Cwd, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(process, "cwd", Cwd); env->SetMethod(process, "dlopen", DLOpen); env->SetMethod(process, "reallyExit", Exit); - env->SetMethod(process, "uptime", Uptime, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(process, "uptime", Uptime); #if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__) - env->SetMethod(process, "getuid", GetUid, - SideEffectType::kHasNoSideEffect); - env->SetMethod(process, "geteuid", GetEUid, - SideEffectType::kHasNoSideEffect); - env->SetMethod(process, "getgid", GetGid, - SideEffectType::kHasNoSideEffect); - env->SetMethod(process, "getegid", GetEGid, - SideEffectType::kHasNoSideEffect); - env->SetMethod(process, "getgroups", GetGroups, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(process, "getuid", GetUid); + env->SetSafeMethod(process, "geteuid", GetEUid); + env->SetSafeMethod(process, "getgid", GetGid); + env->SetSafeMethod(process, "getegid", GetEGid); + env->SetSafeMethod(process, "getgroups", GetGroups); #endif // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__) } diff --git a/src/node_buffer.cc b/src/node_buffer.cc index 4be3d34822c36f..580a9bc9e92399 100644 --- a/src/node_buffer.cc +++ b/src/node_buffer.cc @@ -82,7 +82,6 @@ using v8::Local; using v8::Maybe; using v8::MaybeLocal; using v8::Object; -using v8::SideEffectType; using v8::String; using v8::Uint32Array; using v8::Uint8Array; @@ -1084,18 +1083,12 @@ void SetupBufferJS(const FunctionCallbackInfo& args) { Local proto = args[0].As(); env->set_buffer_prototype_object(proto); - env->SetMethod(proto, "asciiSlice", StringSlice, - SideEffectType::kHasNoSideEffect); - env->SetMethod(proto, "base64Slice", StringSlice, - SideEffectType::kHasNoSideEffect); - env->SetMethod(proto, "latin1Slice", StringSlice, - SideEffectType::kHasNoSideEffect); - env->SetMethod(proto, "hexSlice", StringSlice, - SideEffectType::kHasNoSideEffect); - env->SetMethod(proto, "ucs2Slice", StringSlice, - SideEffectType::kHasNoSideEffect); - env->SetMethod(proto, "utf8Slice", StringSlice, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(proto, "asciiSlice", StringSlice); + env->SetSafeMethod(proto, "base64Slice", StringSlice); + env->SetSafeMethod(proto, "latin1Slice", StringSlice); + env->SetSafeMethod(proto, "hexSlice", StringSlice); + env->SetSafeMethod(proto, "ucs2Slice", StringSlice); + env->SetSafeMethod(proto, "utf8Slice", StringSlice); env->SetMethod(proto, "asciiWrite", StringWrite); env->SetMethod(proto, "base64Write", StringWrite); @@ -1123,30 +1116,22 @@ void Initialize(Local target, Environment* env = Environment::GetCurrent(context); env->SetMethod(target, "setupBufferJS", SetupBufferJS); - env->SetMethod(target, "createFromString", CreateFromString, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "createFromString", CreateFromString); - env->SetMethod(target, "byteLengthUtf8", ByteLengthUtf8, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "byteLengthUtf8", ByteLengthUtf8); env->SetMethod(target, "copy", Copy); - env->SetMethod(target, "compare", Compare, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "compareOffset", CompareOffset, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "compare", Compare); + env->SetSafeMethod(target, "compareOffset", CompareOffset); env->SetMethod(target, "fill", Fill); - env->SetMethod(target, "indexOfBuffer", IndexOfBuffer, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "indexOfNumber", IndexOfNumber, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "indexOfString", IndexOfString, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "indexOfBuffer", IndexOfBuffer); + env->SetSafeMethod(target, "indexOfNumber", IndexOfNumber); + env->SetSafeMethod(target, "indexOfString", IndexOfString); env->SetMethod(target, "swap16", Swap16); env->SetMethod(target, "swap32", Swap32); env->SetMethod(target, "swap64", Swap64); - env->SetMethod(target, "encodeUtf8String", EncodeUtf8String, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "encodeUtf8String", EncodeUtf8String); target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"), diff --git a/src/node_crypto.cc b/src/node_crypto.cc index c40b8a720d2368..d10d2967408faa 100644 --- a/src/node_crypto.cc +++ b/src/node_crypto.cc @@ -348,15 +348,12 @@ void SecureContext::Initialize(Environment* env, Local target) { #ifndef OPENSSL_NO_ENGINE env->SetProtoMethod(t, "setClientCertEngine", SetClientCertEngine); #endif // !OPENSSL_NO_ENGINE - env->SetProtoMethod(t, "getTicketKeys", GetTicketKeys, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getTicketKeys", GetTicketKeys); env->SetProtoMethod(t, "setTicketKeys", SetTicketKeys); env->SetProtoMethod(t, "setFreeListLength", SetFreeListLength); env->SetProtoMethod(t, "enableTicketKeyCallback", EnableTicketKeyCallback); - env->SetProtoMethod(t, "getCertificate", GetCertificate, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getIssuer", GetCertificate, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getCertificate", GetCertificate); + env->SetSafeProtoMethod(t, "getIssuer", GetCertificate); t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyReturnIndex"), Integer::NewFromUnsigned(env->isolate(), kTicketKeyReturnIndex)); @@ -1372,44 +1369,32 @@ template void SSLWrap::AddMethods(Environment* env, Local t) { HandleScope scope(env->isolate()); - env->SetProtoMethod(t, "getPeerCertificate", GetPeerCertificate, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getFinished", GetFinished, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getPeerFinished", GetPeerFinished, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getSession", GetSession, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getPeerCertificate", GetPeerCertificate); + env->SetSafeProtoMethod(t, "getFinished", GetFinished); + env->SetSafeProtoMethod(t, "getPeerFinished", GetPeerFinished); + env->SetSafeProtoMethod(t, "getSession", GetSession); env->SetProtoMethod(t, "setSession", SetSession); env->SetProtoMethod(t, "loadSession", LoadSession); - env->SetProtoMethod(t, "isSessionReused", IsSessionReused, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "isInitFinished", IsInitFinished, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "verifyError", VerifyError, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getCurrentCipher", GetCurrentCipher, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "isSessionReused", IsSessionReused); + env->SetSafeProtoMethod(t, "isInitFinished", IsInitFinished); + env->SetSafeProtoMethod(t, "verifyError", VerifyError); + env->SetSafeProtoMethod(t, "getCurrentCipher", GetCurrentCipher); env->SetProtoMethod(t, "endParser", EndParser); env->SetProtoMethod(t, "certCbDone", CertCbDone); env->SetProtoMethod(t, "renegotiate", Renegotiate); env->SetProtoMethod(t, "shutdownSSL", Shutdown); - env->SetProtoMethod(t, "getTLSTicket", GetTLSTicket, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getTLSTicket", GetTLSTicket); env->SetProtoMethod(t, "newSessionDone", NewSessionDone); env->SetProtoMethod(t, "setOCSPResponse", SetOCSPResponse); env->SetProtoMethod(t, "requestOCSP", RequestOCSP); - env->SetProtoMethod(t, "getEphemeralKeyInfo", GetEphemeralKeyInfo, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getProtocol", GetProtocol, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getEphemeralKeyInfo", GetEphemeralKeyInfo); + env->SetSafeProtoMethod(t, "getProtocol", GetProtocol); #ifdef SSL_set_max_send_fragment env->SetProtoMethod(t, "setMaxSendFragment", SetMaxSendFragment); #endif // SSL_set_max_send_fragment - env->SetProtoMethod(t, "getALPNNegotiatedProtocol", GetALPNNegotiatedProto, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getALPNNegotiatedProtocol", GetALPNNegotiatedProto); env->SetProtoMethod(t, "setALPNProtocols", SetALPNProtocols); } @@ -2580,8 +2565,7 @@ void CipherBase::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "update", Update); env->SetProtoMethod(t, "final", Final); env->SetProtoMethod(t, "setAutoPadding", SetAutoPadding); - env->SetProtoMethod(t, "getAuthTag", GetAuthTag, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getAuthTag", GetAuthTag); env->SetProtoMethod(t, "setAuthTag", SetAuthTag); env->SetProtoMethod(t, "setAAD", SetAAD); @@ -3916,14 +3900,10 @@ void DiffieHellman::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "generateKeys", GenerateKeys); env->SetProtoMethod(t, "computeSecret", ComputeSecret); - env->SetProtoMethod(t, "getPrime", GetPrime, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getGenerator", GetGenerator, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getPublicKey", GetPublicKey, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getPrime", GetPrime); + env->SetSafeProtoMethod(t, "getGenerator", GetGenerator); + env->SetSafeProtoMethod(t, "getPublicKey", GetPublicKey); + env->SetSafeProtoMethod(t, "getPrivateKey", GetPrivateKey); env->SetProtoMethod(t, "setPublicKey", SetPublicKey); env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey); @@ -3932,6 +3912,7 @@ void DiffieHellman::Initialize(Environment* env, Local target) { DiffieHellman::VerifyErrorGetter, env->as_external(), Signature::New(env->isolate(), t), + /* length */ 0, // TODO(TimothyGu): should be deny ConstructorBehavior::kAllow, SideEffectType::kHasNoSideEffect); @@ -3950,20 +3931,17 @@ void DiffieHellman::Initialize(Environment* env, Local target) { env->SetProtoMethod(t2, "generateKeys", GenerateKeys); env->SetProtoMethod(t2, "computeSecret", ComputeSecret); - env->SetProtoMethod(t2, "getPrime", GetPrime, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t2, "getGenerator", GetGenerator, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t2, "getPublicKey", GetPublicKey, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t2, "getPrivateKey", GetPrivateKey, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t2, "getPrime", GetPrime); + env->SetSafeProtoMethod(t2, "getGenerator", GetGenerator); + env->SetSafeProtoMethod(t2, "getPublicKey", GetPublicKey); + env->SetSafeProtoMethod(t2, "getPrivateKey", GetPrivateKey); Local verify_error_getter_templ2 = FunctionTemplate::New(env->isolate(), DiffieHellman::VerifyErrorGetter, env->as_external(), Signature::New(env->isolate(), t2), + /* length */ 0, // TODO(TimothyGu): should be deny ConstructorBehavior::kAllow, SideEffectType::kHasNoSideEffect); @@ -4318,10 +4296,8 @@ void ECDH::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "generateKeys", GenerateKeys); env->SetProtoMethod(t, "computeSecret", ComputeSecret); - env->SetProtoMethod(t, "getPublicKey", GetPublicKey, - SideEffectType::kHasNoSideEffect); - env->SetProtoMethod(t, "getPrivateKey", GetPrivateKey, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getPublicKey", GetPublicKey); + env->SetSafeProtoMethod(t, "getPrivateKey", GetPrivateKey); env->SetProtoMethod(t, "setPublicKey", SetPublicKey); env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey); @@ -5212,37 +5188,27 @@ void Initialize(Local target, Sign::Initialize(env, target); Verify::Initialize(env, target); - env->SetMethod(target, "certVerifySpkac", VerifySpkac, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "certExportPublicKey", ExportPublicKey, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "certExportChallenge", ExportChallenge, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "certVerifySpkac", VerifySpkac); + env->SetSafeMethod(target, "certExportPublicKey", ExportPublicKey); + env->SetSafeMethod(target, "certExportChallenge", ExportChallenge); - env->SetMethod(target, "ECDHConvertKey", ConvertKey, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "ECDHConvertKey", ConvertKey); #ifndef OPENSSL_NO_ENGINE env->SetMethod(target, "setEngine", SetEngine); #endif // !OPENSSL_NO_ENGINE #ifdef NODE_FIPS_MODE - env->SetMethod(target, "getFipsCrypto", GetFipsCrypto, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "getFipsCrypto", GetFipsCrypto); env->SetMethod(target, "setFipsCrypto", SetFipsCrypto); #endif env->SetMethod(target, "pbkdf2", PBKDF2); env->SetMethod(target, "randomBytes", RandomBytes); - env->SetMethod(target, "timingSafeEqual", TimingSafeEqual, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "getSSLCiphers", GetSSLCiphers, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "getCiphers", GetCiphers, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "getHashes", GetHashes, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "getCurves", GetCurves, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "timingSafeEqual", TimingSafeEqual); + env->SetSafeMethod(target, "getSSLCiphers", GetSSLCiphers); + env->SetSafeMethod(target, "getCiphers", GetCiphers); + env->SetSafeMethod(target, "getHashes", GetHashes); + env->SetSafeMethod(target, "getCurves", GetCurves); env->SetMethod(target, "publicEncrypt", PublicKeyCipher::Cipher target, Local context) { Environment* env = Environment::GetCurrent(context); -#define V(type) env->SetMethod(target, \ - "is" #type, \ - Is##type, \ - SideEffectType::kHasNoSideEffect); +#define V(type) env->SetSafeMethod(target, \ + "is" #type, \ + Is##type); VALUE_METHOD_MAP(V) #undef V - env->SetMethod(target, "isAnyArrayBuffer", IsAnyArrayBuffer, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "isAnyArrayBuffer", IsAnyArrayBuffer); } } // anonymous namespace diff --git a/src/node_url.cc b/src/node_url.cc index e34274f8738cde..4617b34c7a0785 100644 --- a/src/node_url.cc +++ b/src/node_url.cc @@ -22,7 +22,6 @@ using v8::Local; using v8::MaybeLocal; using v8::Null; using v8::Object; -using v8::SideEffectType; using v8::String; using v8::TryCatch; using v8::Undefined; @@ -2335,14 +2334,10 @@ static void Initialize(Local target, void* priv) { Environment* env = Environment::GetCurrent(context); env->SetMethod(target, "parse", Parse); - env->SetMethod(target, "encodeAuth", EncodeAuthSet, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "toUSVString", ToUSVString, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "domainToASCII", DomainToASCII, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "domainToUnicode", DomainToUnicode, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "encodeAuth", EncodeAuthSet); + env->SetSafeMethod(target, "toUSVString", ToUSVString); + env->SetSafeMethod(target, "domainToASCII", DomainToASCII); + env->SetSafeMethod(target, "domainToUnicode", DomainToUnicode); env->SetMethod(target, "setURLConstructor", SetURLConstructor); #define XX(name, _) NODE_DEFINE_CONSTANT(target, name); diff --git a/src/node_util.cc b/src/node_util.cc index b9946652fe248a..203ac69f01623a 100644 --- a/src/node_util.cc +++ b/src/node_util.cc @@ -14,7 +14,6 @@ using v8::Object; using v8::Private; using v8::Promise; using v8::Proxy; -using v8::SideEffectType; using v8::String; using v8::Value; @@ -213,25 +212,19 @@ void Initialize(Local target, V(kRejected); #undef V - env->SetMethod(target, "getHiddenValue", GetHiddenValue, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "getHiddenValue", GetHiddenValue); env->SetMethod(target, "setHiddenValue", SetHiddenValue); - env->SetMethod(target, "getPromiseDetails", GetPromiseDetails, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "getProxyDetails", GetProxyDetails, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "safeToString", SafeToString, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "previewEntries", PreviewEntries, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "getPromiseDetails", GetPromiseDetails); + env->SetSafeMethod(target, "getProxyDetails", GetProxyDetails); + env->SetSafeMethod(target, "safeToString", SafeToString); + env->SetSafeMethod(target, "previewEntries", PreviewEntries); env->SetMethod(target, "startSigintWatchdog", StartSigintWatchdog); env->SetMethod(target, "stopSigintWatchdog", StopSigintWatchdog); - env->SetMethod(target, "watchdogHasPendingSigint", WatchdogHasPendingSigint, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "watchdogHasPendingSigint", + WatchdogHasPendingSigint); - env->SetMethod(target, "createPromise", CreatePromise, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "createPromise", CreatePromise); env->SetMethod(target, "promiseResolve", PromiseResolve); env->SetMethod(target, "promiseReject", PromiseReject); diff --git a/src/node_v8.cc b/src/node_v8.cc index 3e6597ee6041f5..4020d0be79c3ef 100644 --- a/src/node_v8.cc +++ b/src/node_v8.cc @@ -39,7 +39,6 @@ using v8::Local; using v8::NewStringType; using v8::Object; using v8::ScriptCompiler; -using v8::SideEffectType; using v8::String; using v8::Uint32; using v8::V8; @@ -123,8 +122,7 @@ void Initialize(Local target, Local context) { Environment* env = Environment::GetCurrent(context); - env->SetMethod(target, "cachedDataVersionTag", CachedDataVersionTag, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "cachedDataVersionTag", CachedDataVersionTag); env->SetMethod(target, "updateHeapStatisticsArrayBuffer", diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc index 319793bf7abb86..3e6aabec803dbf 100644 --- a/src/tty_wrap.cc +++ b/src/tty_wrap.cc @@ -38,7 +38,6 @@ using v8::FunctionTemplate; using v8::Integer; using v8::Local; using v8::Object; -using v8::SideEffectType; using v8::String; using v8::Value; @@ -59,19 +58,15 @@ void TTYWrap::Initialize(Local target, env->SetProtoMethod(t, "close", HandleWrap::Close); env->SetProtoMethod(t, "unref", HandleWrap::Unref); env->SetProtoMethod(t, "ref", HandleWrap::Ref); - env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "hasRef", HandleWrap::HasRef); LibuvStreamWrap::AddMethods(env, t); - env->SetProtoMethod(t, "getWindowSize", TTYWrap::GetWindowSize, - SideEffectType::kHasNoSideEffect); + env->SetSafeProtoMethod(t, "getWindowSize", TTYWrap::GetWindowSize); env->SetProtoMethod(t, "setRawMode", SetRawMode); - env->SetMethod(target, "isTTY", IsTTY, - SideEffectType::kHasNoSideEffect); - env->SetMethod(target, "guessHandleType", GuessHandleType, - SideEffectType::kHasNoSideEffect); + env->SetSafeMethod(target, "isTTY", IsTTY); + env->SetSafeMethod(target, "guessHandleType", GuessHandleType); target->Set(ttyString, t->GetFunction()); env->set_tty_constructor_template(t); From a129a6f851c97f9a48b68fae44d8ab524b168c86 Mon Sep 17 00:00:00 2001 From: Timothy Gu Date: Fri, 22 Jun 2018 21:50:22 -0400 Subject: [PATCH 4/5] fixup! src: start annotating native code side effect --- src/node_crypto.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/node_crypto.cc b/src/node_crypto.cc index d10d2967408faa..f2fddb8492dc93 100644 --- a/src/node_crypto.cc +++ b/src/node_crypto.cc @@ -1394,7 +1394,8 @@ void SSLWrap::AddMethods(Environment* env, Local t) { env->SetProtoMethod(t, "setMaxSendFragment", SetMaxSendFragment); #endif // SSL_set_max_send_fragment - env->SetSafeProtoMethod(t, "getALPNNegotiatedProtocol", GetALPNNegotiatedProto); + env->SetSafeProtoMethod(t, "getALPNNegotiatedProtocol", + GetALPNNegotiatedProto); env->SetProtoMethod(t, "setALPNProtocols", SetALPNProtocols); } From c43658d2250fdf9fa314712f5c9b2564b64644e5 Mon Sep 17 00:00:00 2001 From: Timothy Gu Date: Sun, 24 Jun 2018 12:52:46 -0400 Subject: [PATCH 5/5] fixup! fixup! src: start annotating native code side effect --- src/cares_wrap.cc | 6 ++-- src/env-inl.h | 13 +++---- src/env.h | 15 +++++---- src/inspector_js_api.cc | 4 +-- src/module_wrap.cc | 10 +++--- src/node.cc | 14 ++++---- src/node_buffer.cc | 28 +++++++-------- src/node_crypto.cc | 75 +++++++++++++++++++++-------------------- src/node_types.cc | 8 ++--- src/node_url.cc | 8 ++--- src/node_util.cc | 16 ++++----- src/node_v8.cc | 3 +- src/tty_wrap.cc | 8 ++--- 13 files changed, 106 insertions(+), 102 deletions(-) diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc index 99f8779e1ab88f..3cf1d434d3ca71 100644 --- a/src/cares_wrap.cc +++ b/src/cares_wrap.cc @@ -2107,8 +2107,8 @@ void Initialize(Local target, env->SetMethod(target, "getaddrinfo", GetAddrInfo); env->SetMethod(target, "getnameinfo", GetNameInfo); - env->SetSafeMethod(target, "isIPv6", IsIPv6); - env->SetSafeMethod(target, "canonicalizeIP", CanonicalizeIP); + env->SetMethodNoSideEffect(target, "isIPv6", IsIPv6); + env->SetMethodNoSideEffect(target, "canonicalizeIP", CanonicalizeIP); env->SetMethod(target, "strerror", StrError); @@ -2165,7 +2165,7 @@ void Initialize(Local target, env->SetProtoMethod(channel_wrap, "querySoa", Query); env->SetProtoMethod(channel_wrap, "getHostByAddr", Query); - env->SetSafeProtoMethod(channel_wrap, "getServers", GetServers); + env->SetProtoMethodNoSideEffect(channel_wrap, "getServers", GetServers); env->SetProtoMethod(channel_wrap, "setServers", SetServers); env->SetProtoMethod(channel_wrap, "cancel", Cancel); diff --git a/src/env-inl.h b/src/env-inl.h index 487cd2544f787e..037f0659ed2ac7 100644 --- a/src/env-inl.h +++ b/src/env-inl.h @@ -700,9 +700,9 @@ inline void Environment::SetMethod(v8::Local that, function->SetName(name_string); // NODE_SET_METHOD() compatibility. } -inline void Environment::SetSafeMethod(v8::Local that, - const char* name, - v8::FunctionCallback callback) { +inline void Environment::SetMethodNoSideEffect(v8::Local that, + const char* name, + v8::FunctionCallback callback) { v8::Local function = NewFunctionTemplate(callback, v8::Local(), @@ -733,8 +733,9 @@ inline void Environment::SetProtoMethod(v8::Local that, t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility. } -inline void Environment::SetSafeProtoMethod( - v8::Local that, const char* name, +inline void Environment::SetProtoMethodNoSideEffect( + v8::Local that, + const char* name, v8::FunctionCallback callback) { v8::Local signature = v8::Signature::New(isolate(), that); v8::Local t = @@ -763,7 +764,7 @@ inline void Environment::SetTemplateMethod(v8::Local that, t->SetClassName(name_string); // NODE_SET_METHOD() compatibility. } -inline void Environment::SetSafeTemplateMethod( +inline void Environment::SetTemplateMethodNoSideEffect( v8::Local that, const char* name, v8::FunctionCallback callback) { diff --git a/src/env.h b/src/env.h index 54ff66aade07a9..3febddea4c6a62 100644 --- a/src/env.h +++ b/src/env.h @@ -769,15 +769,16 @@ class Environment { v8::FunctionCallback callback); // Safe variants denote the function has no side effects. - inline void SetSafeMethod(v8::Local that, - const char* name, - v8::FunctionCallback callback); - inline void SetSafeProtoMethod(v8::Local that, - const char* name, - v8::FunctionCallback callback); - inline void SetSafeTemplateMethod(v8::Local that, + inline void SetMethodNoSideEffect(v8::Local that, const char* name, v8::FunctionCallback callback); + inline void SetProtoMethodNoSideEffect(v8::Local that, + const char* name, + v8::FunctionCallback callback); + inline void SetTemplateMethodNoSideEffect( + v8::Local that, + const char* name, + v8::FunctionCallback callback); void BeforeExit(void (*cb)(void* arg), void* arg); void RunBeforeExitCallbacks(); diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc index babc5706e03f93..fc12f32cd3b5af 100644 --- a/src/inspector_js_api.cc +++ b/src/inspector_js_api.cc @@ -289,7 +289,7 @@ void Initialize(Local target, Local unused, if (agent->IsWaitingForConnect()) env->SetMethod(target, "callAndPauseOnStart", CallAndPauseOnStart); env->SetMethod(target, "open", Open); - env->SetSafeMethod(target, "url", Url); + env->SetMethodNoSideEffect(target, "url", Url); env->SetMethod(target, "asyncTaskScheduled", AsyncTaskScheduledWrapper); env->SetMethod(target, "asyncTaskCanceled", @@ -300,7 +300,7 @@ void Initialize(Local target, Local unused, InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>); env->SetMethod(target, "registerAsyncHook", RegisterAsyncHookWrapper); - env->SetSafeMethod(target, "isEnabled", IsEnabled); + env->SetMethodNoSideEffect(target, "isEnabled", IsEnabled); auto conn_str = FIXED_ONE_BYTE_STRING(env->isolate(), "Connection"); Local tmpl = diff --git a/src/module_wrap.cc b/src/module_wrap.cc index e4da4813b0f2d8..ab1950311ad631 100644 --- a/src/module_wrap.cc +++ b/src/module_wrap.cc @@ -789,11 +789,11 @@ void ModuleWrap::Initialize(Local target, env->SetProtoMethod(tpl, "link", Link); env->SetProtoMethod(tpl, "instantiate", Instantiate); env->SetProtoMethod(tpl, "evaluate", Evaluate); - env->SetSafeProtoMethod(tpl, "namespace", Namespace); - env->SetSafeProtoMethod(tpl, "getStatus", GetStatus); - env->SetSafeProtoMethod(tpl, "getError", GetError); - env->SetSafeProtoMethod(tpl, "getStaticDependencySpecifiers", - GetStaticDependencySpecifiers); + env->SetProtoMethodNoSideEffect(tpl, "namespace", Namespace); + env->SetProtoMethodNoSideEffect(tpl, "getStatus", GetStatus); + env->SetProtoMethodNoSideEffect(tpl, "getError", GetError); + env->SetProtoMethodNoSideEffect(tpl, "getStaticDependencySpecifiers", + GetStaticDependencySpecifiers); target->Set(FIXED_ONE_BYTE_STRING(isolate, "ModuleWrap"), tpl->GetFunction()); env->SetMethod(target, "resolve", Resolve); diff --git a/src/node.cc b/src/node.cc index 9d68488ec6f151..660439371babb3 100644 --- a/src/node.cc +++ b/src/node.cc @@ -2256,17 +2256,17 @@ void SetupProcessObject(Environment* env, env->SetMethod(process, "_getActiveHandles", GetActiveHandles); env->SetMethod(process, "_kill", Kill); - env->SetSafeMethod(process, "cwd", Cwd); + env->SetMethodNoSideEffect(process, "cwd", Cwd); env->SetMethod(process, "dlopen", DLOpen); env->SetMethod(process, "reallyExit", Exit); - env->SetSafeMethod(process, "uptime", Uptime); + env->SetMethodNoSideEffect(process, "uptime", Uptime); #if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__) - env->SetSafeMethod(process, "getuid", GetUid); - env->SetSafeMethod(process, "geteuid", GetEUid); - env->SetSafeMethod(process, "getgid", GetGid); - env->SetSafeMethod(process, "getegid", GetEGid); - env->SetSafeMethod(process, "getgroups", GetGroups); + env->SetMethodNoSideEffect(process, "getuid", GetUid); + env->SetMethodNoSideEffect(process, "geteuid", GetEUid); + env->SetMethodNoSideEffect(process, "getgid", GetGid); + env->SetMethodNoSideEffect(process, "getegid", GetEGid); + env->SetMethodNoSideEffect(process, "getgroups", GetGroups); #endif // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__) } diff --git a/src/node_buffer.cc b/src/node_buffer.cc index 580a9bc9e92399..9eb351b443a111 100644 --- a/src/node_buffer.cc +++ b/src/node_buffer.cc @@ -1083,12 +1083,12 @@ void SetupBufferJS(const FunctionCallbackInfo& args) { Local proto = args[0].As(); env->set_buffer_prototype_object(proto); - env->SetSafeMethod(proto, "asciiSlice", StringSlice); - env->SetSafeMethod(proto, "base64Slice", StringSlice); - env->SetSafeMethod(proto, "latin1Slice", StringSlice); - env->SetSafeMethod(proto, "hexSlice", StringSlice); - env->SetSafeMethod(proto, "ucs2Slice", StringSlice); - env->SetSafeMethod(proto, "utf8Slice", StringSlice); + env->SetMethodNoSideEffect(proto, "asciiSlice", StringSlice); + env->SetMethodNoSideEffect(proto, "base64Slice", StringSlice); + env->SetMethodNoSideEffect(proto, "latin1Slice", StringSlice); + env->SetMethodNoSideEffect(proto, "hexSlice", StringSlice); + env->SetMethodNoSideEffect(proto, "ucs2Slice", StringSlice); + env->SetMethodNoSideEffect(proto, "utf8Slice", StringSlice); env->SetMethod(proto, "asciiWrite", StringWrite); env->SetMethod(proto, "base64Write", StringWrite); @@ -1116,22 +1116,22 @@ void Initialize(Local target, Environment* env = Environment::GetCurrent(context); env->SetMethod(target, "setupBufferJS", SetupBufferJS); - env->SetSafeMethod(target, "createFromString", CreateFromString); + env->SetMethodNoSideEffect(target, "createFromString", CreateFromString); - env->SetSafeMethod(target, "byteLengthUtf8", ByteLengthUtf8); + env->SetMethodNoSideEffect(target, "byteLengthUtf8", ByteLengthUtf8); env->SetMethod(target, "copy", Copy); - env->SetSafeMethod(target, "compare", Compare); - env->SetSafeMethod(target, "compareOffset", CompareOffset); + env->SetMethodNoSideEffect(target, "compare", Compare); + env->SetMethodNoSideEffect(target, "compareOffset", CompareOffset); env->SetMethod(target, "fill", Fill); - env->SetSafeMethod(target, "indexOfBuffer", IndexOfBuffer); - env->SetSafeMethod(target, "indexOfNumber", IndexOfNumber); - env->SetSafeMethod(target, "indexOfString", IndexOfString); + env->SetMethodNoSideEffect(target, "indexOfBuffer", IndexOfBuffer); + env->SetMethodNoSideEffect(target, "indexOfNumber", IndexOfNumber); + env->SetMethodNoSideEffect(target, "indexOfString", IndexOfString); env->SetMethod(target, "swap16", Swap16); env->SetMethod(target, "swap32", Swap32); env->SetMethod(target, "swap64", Swap64); - env->SetSafeMethod(target, "encodeUtf8String", EncodeUtf8String); + env->SetMethodNoSideEffect(target, "encodeUtf8String", EncodeUtf8String); target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"), diff --git a/src/node_crypto.cc b/src/node_crypto.cc index f2fddb8492dc93..02f2aad13700f0 100644 --- a/src/node_crypto.cc +++ b/src/node_crypto.cc @@ -348,12 +348,12 @@ void SecureContext::Initialize(Environment* env, Local target) { #ifndef OPENSSL_NO_ENGINE env->SetProtoMethod(t, "setClientCertEngine", SetClientCertEngine); #endif // !OPENSSL_NO_ENGINE - env->SetSafeProtoMethod(t, "getTicketKeys", GetTicketKeys); + env->SetProtoMethodNoSideEffect(t, "getTicketKeys", GetTicketKeys); env->SetProtoMethod(t, "setTicketKeys", SetTicketKeys); env->SetProtoMethod(t, "setFreeListLength", SetFreeListLength); env->SetProtoMethod(t, "enableTicketKeyCallback", EnableTicketKeyCallback); - env->SetSafeProtoMethod(t, "getCertificate", GetCertificate); - env->SetSafeProtoMethod(t, "getIssuer", GetCertificate); + env->SetProtoMethodNoSideEffect(t, "getCertificate", GetCertificate); + env->SetProtoMethodNoSideEffect(t, "getIssuer", GetCertificate); t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kTicketKeyReturnIndex"), Integer::NewFromUnsigned(env->isolate(), kTicketKeyReturnIndex)); @@ -1369,33 +1369,34 @@ template void SSLWrap::AddMethods(Environment* env, Local t) { HandleScope scope(env->isolate()); - env->SetSafeProtoMethod(t, "getPeerCertificate", GetPeerCertificate); - env->SetSafeProtoMethod(t, "getFinished", GetFinished); - env->SetSafeProtoMethod(t, "getPeerFinished", GetPeerFinished); - env->SetSafeProtoMethod(t, "getSession", GetSession); + env->SetProtoMethodNoSideEffect(t, "getPeerCertificate", GetPeerCertificate); + env->SetProtoMethodNoSideEffect(t, "getFinished", GetFinished); + env->SetProtoMethodNoSideEffect(t, "getPeerFinished", GetPeerFinished); + env->SetProtoMethodNoSideEffect(t, "getSession", GetSession); env->SetProtoMethod(t, "setSession", SetSession); env->SetProtoMethod(t, "loadSession", LoadSession); - env->SetSafeProtoMethod(t, "isSessionReused", IsSessionReused); - env->SetSafeProtoMethod(t, "isInitFinished", IsInitFinished); - env->SetSafeProtoMethod(t, "verifyError", VerifyError); - env->SetSafeProtoMethod(t, "getCurrentCipher", GetCurrentCipher); + env->SetProtoMethodNoSideEffect(t, "isSessionReused", IsSessionReused); + env->SetProtoMethodNoSideEffect(t, "isInitFinished", IsInitFinished); + env->SetProtoMethodNoSideEffect(t, "verifyError", VerifyError); + env->SetProtoMethodNoSideEffect(t, "getCurrentCipher", GetCurrentCipher); env->SetProtoMethod(t, "endParser", EndParser); env->SetProtoMethod(t, "certCbDone", CertCbDone); env->SetProtoMethod(t, "renegotiate", Renegotiate); env->SetProtoMethod(t, "shutdownSSL", Shutdown); - env->SetSafeProtoMethod(t, "getTLSTicket", GetTLSTicket); + env->SetProtoMethodNoSideEffect(t, "getTLSTicket", GetTLSTicket); env->SetProtoMethod(t, "newSessionDone", NewSessionDone); env->SetProtoMethod(t, "setOCSPResponse", SetOCSPResponse); env->SetProtoMethod(t, "requestOCSP", RequestOCSP); - env->SetSafeProtoMethod(t, "getEphemeralKeyInfo", GetEphemeralKeyInfo); - env->SetSafeProtoMethod(t, "getProtocol", GetProtocol); + env->SetProtoMethodNoSideEffect(t, "getEphemeralKeyInfo", + GetEphemeralKeyInfo); + env->SetProtoMethodNoSideEffect(t, "getProtocol", GetProtocol); #ifdef SSL_set_max_send_fragment env->SetProtoMethod(t, "setMaxSendFragment", SetMaxSendFragment); #endif // SSL_set_max_send_fragment - env->SetSafeProtoMethod(t, "getALPNNegotiatedProtocol", - GetALPNNegotiatedProto); + env->SetProtoMethodNoSideEffect(t, "getALPNNegotiatedProtocol", + GetALPNNegotiatedProto); env->SetProtoMethod(t, "setALPNProtocols", SetALPNProtocols); } @@ -2566,7 +2567,7 @@ void CipherBase::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "update", Update); env->SetProtoMethod(t, "final", Final); env->SetProtoMethod(t, "setAutoPadding", SetAutoPadding); - env->SetSafeProtoMethod(t, "getAuthTag", GetAuthTag); + env->SetProtoMethodNoSideEffect(t, "getAuthTag", GetAuthTag); env->SetProtoMethod(t, "setAuthTag", SetAuthTag); env->SetProtoMethod(t, "setAAD", SetAAD); @@ -3901,10 +3902,10 @@ void DiffieHellman::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "generateKeys", GenerateKeys); env->SetProtoMethod(t, "computeSecret", ComputeSecret); - env->SetSafeProtoMethod(t, "getPrime", GetPrime); - env->SetSafeProtoMethod(t, "getGenerator", GetGenerator); - env->SetSafeProtoMethod(t, "getPublicKey", GetPublicKey); - env->SetSafeProtoMethod(t, "getPrivateKey", GetPrivateKey); + env->SetProtoMethodNoSideEffect(t, "getPrime", GetPrime); + env->SetProtoMethodNoSideEffect(t, "getGenerator", GetGenerator); + env->SetProtoMethodNoSideEffect(t, "getPublicKey", GetPublicKey); + env->SetProtoMethodNoSideEffect(t, "getPrivateKey", GetPrivateKey); env->SetProtoMethod(t, "setPublicKey", SetPublicKey); env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey); @@ -3932,10 +3933,10 @@ void DiffieHellman::Initialize(Environment* env, Local target) { env->SetProtoMethod(t2, "generateKeys", GenerateKeys); env->SetProtoMethod(t2, "computeSecret", ComputeSecret); - env->SetSafeProtoMethod(t2, "getPrime", GetPrime); - env->SetSafeProtoMethod(t2, "getGenerator", GetGenerator); - env->SetSafeProtoMethod(t2, "getPublicKey", GetPublicKey); - env->SetSafeProtoMethod(t2, "getPrivateKey", GetPrivateKey); + env->SetProtoMethodNoSideEffect(t2, "getPrime", GetPrime); + env->SetProtoMethodNoSideEffect(t2, "getGenerator", GetGenerator); + env->SetProtoMethodNoSideEffect(t2, "getPublicKey", GetPublicKey); + env->SetProtoMethodNoSideEffect(t2, "getPrivateKey", GetPrivateKey); Local verify_error_getter_templ2 = FunctionTemplate::New(env->isolate(), @@ -4297,8 +4298,8 @@ void ECDH::Initialize(Environment* env, Local target) { env->SetProtoMethod(t, "generateKeys", GenerateKeys); env->SetProtoMethod(t, "computeSecret", ComputeSecret); - env->SetSafeProtoMethod(t, "getPublicKey", GetPublicKey); - env->SetSafeProtoMethod(t, "getPrivateKey", GetPrivateKey); + env->SetProtoMethodNoSideEffect(t, "getPublicKey", GetPublicKey); + env->SetProtoMethodNoSideEffect(t, "getPrivateKey", GetPrivateKey); env->SetProtoMethod(t, "setPublicKey", SetPublicKey); env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey); @@ -5189,27 +5190,27 @@ void Initialize(Local target, Sign::Initialize(env, target); Verify::Initialize(env, target); - env->SetSafeMethod(target, "certVerifySpkac", VerifySpkac); - env->SetSafeMethod(target, "certExportPublicKey", ExportPublicKey); - env->SetSafeMethod(target, "certExportChallenge", ExportChallenge); + env->SetMethodNoSideEffect(target, "certVerifySpkac", VerifySpkac); + env->SetMethodNoSideEffect(target, "certExportPublicKey", ExportPublicKey); + env->SetMethodNoSideEffect(target, "certExportChallenge", ExportChallenge); - env->SetSafeMethod(target, "ECDHConvertKey", ConvertKey); + env->SetMethodNoSideEffect(target, "ECDHConvertKey", ConvertKey); #ifndef OPENSSL_NO_ENGINE env->SetMethod(target, "setEngine", SetEngine); #endif // !OPENSSL_NO_ENGINE #ifdef NODE_FIPS_MODE - env->SetSafeMethod(target, "getFipsCrypto", GetFipsCrypto); + env->SetMethodNoSideEffect(target, "getFipsCrypto", GetFipsCrypto); env->SetMethod(target, "setFipsCrypto", SetFipsCrypto); #endif env->SetMethod(target, "pbkdf2", PBKDF2); env->SetMethod(target, "randomBytes", RandomBytes); - env->SetSafeMethod(target, "timingSafeEqual", TimingSafeEqual); - env->SetSafeMethod(target, "getSSLCiphers", GetSSLCiphers); - env->SetSafeMethod(target, "getCiphers", GetCiphers); - env->SetSafeMethod(target, "getHashes", GetHashes); - env->SetSafeMethod(target, "getCurves", GetCurves); + env->SetMethodNoSideEffect(target, "timingSafeEqual", TimingSafeEqual); + env->SetMethodNoSideEffect(target, "getSSLCiphers", GetSSLCiphers); + env->SetMethodNoSideEffect(target, "getCiphers", GetCiphers); + env->SetMethodNoSideEffect(target, "getHashes", GetHashes); + env->SetMethodNoSideEffect(target, "getCurves", GetCurves); env->SetMethod(target, "publicEncrypt", PublicKeyCipher::Cipher target, Local context) { Environment* env = Environment::GetCurrent(context); -#define V(type) env->SetSafeMethod(target, \ - "is" #type, \ - Is##type); +#define V(type) env->SetMethodNoSideEffect(target, \ + "is" #type, \ + Is##type); VALUE_METHOD_MAP(V) #undef V - env->SetSafeMethod(target, "isAnyArrayBuffer", IsAnyArrayBuffer); + env->SetMethodNoSideEffect(target, "isAnyArrayBuffer", IsAnyArrayBuffer); } } // anonymous namespace diff --git a/src/node_url.cc b/src/node_url.cc index 4617b34c7a0785..1cdb179ed254f5 100644 --- a/src/node_url.cc +++ b/src/node_url.cc @@ -2334,10 +2334,10 @@ static void Initialize(Local target, void* priv) { Environment* env = Environment::GetCurrent(context); env->SetMethod(target, "parse", Parse); - env->SetSafeMethod(target, "encodeAuth", EncodeAuthSet); - env->SetSafeMethod(target, "toUSVString", ToUSVString); - env->SetSafeMethod(target, "domainToASCII", DomainToASCII); - env->SetSafeMethod(target, "domainToUnicode", DomainToUnicode); + env->SetMethodNoSideEffect(target, "encodeAuth", EncodeAuthSet); + env->SetMethodNoSideEffect(target, "toUSVString", ToUSVString); + env->SetMethodNoSideEffect(target, "domainToASCII", DomainToASCII); + env->SetMethodNoSideEffect(target, "domainToUnicode", DomainToUnicode); env->SetMethod(target, "setURLConstructor", SetURLConstructor); #define XX(name, _) NODE_DEFINE_CONSTANT(target, name); diff --git a/src/node_util.cc b/src/node_util.cc index 203ac69f01623a..724bb3603cfddd 100644 --- a/src/node_util.cc +++ b/src/node_util.cc @@ -212,19 +212,19 @@ void Initialize(Local target, V(kRejected); #undef V - env->SetSafeMethod(target, "getHiddenValue", GetHiddenValue); + env->SetMethodNoSideEffect(target, "getHiddenValue", GetHiddenValue); env->SetMethod(target, "setHiddenValue", SetHiddenValue); - env->SetSafeMethod(target, "getPromiseDetails", GetPromiseDetails); - env->SetSafeMethod(target, "getProxyDetails", GetProxyDetails); - env->SetSafeMethod(target, "safeToString", SafeToString); - env->SetSafeMethod(target, "previewEntries", PreviewEntries); + env->SetMethodNoSideEffect(target, "getPromiseDetails", GetPromiseDetails); + env->SetMethodNoSideEffect(target, "getProxyDetails", GetProxyDetails); + env->SetMethodNoSideEffect(target, "safeToString", SafeToString); + env->SetMethodNoSideEffect(target, "previewEntries", PreviewEntries); env->SetMethod(target, "startSigintWatchdog", StartSigintWatchdog); env->SetMethod(target, "stopSigintWatchdog", StopSigintWatchdog); - env->SetSafeMethod(target, "watchdogHasPendingSigint", - WatchdogHasPendingSigint); + env->SetMethodNoSideEffect(target, "watchdogHasPendingSigint", + WatchdogHasPendingSigint); - env->SetSafeMethod(target, "createPromise", CreatePromise); + env->SetMethodNoSideEffect(target, "createPromise", CreatePromise); env->SetMethod(target, "promiseResolve", PromiseResolve); env->SetMethod(target, "promiseReject", PromiseReject); diff --git a/src/node_v8.cc b/src/node_v8.cc index 4020d0be79c3ef..fb0a9fea1e5d27 100644 --- a/src/node_v8.cc +++ b/src/node_v8.cc @@ -122,7 +122,8 @@ void Initialize(Local target, Local context) { Environment* env = Environment::GetCurrent(context); - env->SetSafeMethod(target, "cachedDataVersionTag", CachedDataVersionTag); + env->SetMethodNoSideEffect(target, "cachedDataVersionTag", + CachedDataVersionTag); env->SetMethod(target, "updateHeapStatisticsArrayBuffer", diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc index 3e6aabec803dbf..83b6e34d630e73 100644 --- a/src/tty_wrap.cc +++ b/src/tty_wrap.cc @@ -58,15 +58,15 @@ void TTYWrap::Initialize(Local target, env->SetProtoMethod(t, "close", HandleWrap::Close); env->SetProtoMethod(t, "unref", HandleWrap::Unref); env->SetProtoMethod(t, "ref", HandleWrap::Ref); - env->SetSafeProtoMethod(t, "hasRef", HandleWrap::HasRef); + env->SetProtoMethodNoSideEffect(t, "hasRef", HandleWrap::HasRef); LibuvStreamWrap::AddMethods(env, t); - env->SetSafeProtoMethod(t, "getWindowSize", TTYWrap::GetWindowSize); + env->SetProtoMethodNoSideEffect(t, "getWindowSize", TTYWrap::GetWindowSize); env->SetProtoMethod(t, "setRawMode", SetRawMode); - env->SetSafeMethod(target, "isTTY", IsTTY); - env->SetSafeMethod(target, "guessHandleType", GuessHandleType); + env->SetMethodNoSideEffect(target, "isTTY", IsTTY); + env->SetMethodNoSideEffect(target, "guessHandleType", GuessHandleType); target->Set(ttyString, t->GetFunction()); env->set_tty_constructor_template(t);