Fix Node.js v10.12.0 deprecation warnings.

nan.h

@@ -1060,8 +1060,10 @@ class Utf8String {
       length_(0), str_(str_st_) {
     HandleScope scope;
     if (!from.IsEmpty()) {
-#if V8_MAJOR_VERSION >= 7
-      v8::Local<v8::String> string = from->ToString(v8::Isolate::GetCurrent());
+#if NODE_MAJOR_VERSION >= 10
+      v8::Local<v8::Context> context = GetCurrentContext();
+      v8::Local<v8::String> string =
+          from->ToString(context).FromMaybe(v8::Local<v8::String>());
 #else
       v8::Local<v8::String> string = from->ToString();
 #endif
@@ -1074,7 +1076,7 @@ class Utf8String {
         }
         const int flags =
             v8::String::NO_NULL_TERMINATION | imp::kReplaceInvalidUtf8;
-#if V8_MAJOR_VERSION >= 7
+#if NODE_MAJOR_VERSION >= 10
         length_ = string->WriteUtf8(v8::Isolate::GetCurrent(), str_, static_cast<int>(len), 0, flags);
 #else
         length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
@@ -1852,36 +1854,41 @@ inline MaybeLocal<v8::Value> Call(
   inline void SaveToPersistent(
       const char *key, const v8::Local<v8::Value> &value) {
     HandleScope scope;
-    New(persistentHandle)->Set(New(key).ToLocalChecked(), value);
+    Set(New(persistentHandle), New(key).ToLocalChecked(), value).FromJust();
   }
 
   inline void SaveToPersistent(
       const v8::Local<v8::String> &key, const v8::Local<v8::Value> &value) {
     HandleScope scope;
-    New(persistentHandle)->Set(key, value);
+    Set(New(persistentHandle), key, value).FromJust();
   }
 
   inline void SaveToPersistent(
       uint32_t index, const v8::Local<v8::Value> &value) {
     HandleScope scope;
-    New(persistentHandle)->Set(index, value);
+    Set(New(persistentHandle), index, value).FromJust();
   }
 
   inline v8::Local<v8::Value> GetFromPersistent(const char *key) const {
     EscapableHandleScope scope;
     return scope.Escape(
-        New(persistentHandle)->Get(New(key).ToLocalChecked()));
+        Get(New(persistentHandle), New(key).ToLocalChecked())
+        .FromMaybe(v8::Local<v8::Value>()));
   }
 
   inline v8::Local<v8::Value>
   GetFromPersistent(const v8::Local<v8::String> &key) const {
     EscapableHandleScope scope;
-    return scope.Escape(New(persistentHandle)->Get(key));
+    return scope.Escape(
+        Get(New(persistentHandle), key)
+        .FromMaybe(v8::Local<v8::Value>()));
   }
 
   inline v8::Local<v8::Value> GetFromPersistent(uint32_t index) const {
     EscapableHandleScope scope;
-    return scope.Escape(New(persistentHandle)->Get(index));
+    return scope.Escape(
+        Get(New(persistentHandle), index)
+        .FromMaybe(v8::Local<v8::Value>()));
   }
 
   virtual void Execute() = 0;
@@ -2375,7 +2382,7 @@ SetMethodAux(T recv,
              v8::Local<v8::String> name,
              v8::Local<v8::FunctionTemplate> tpl,
              ...) {
-  recv->Set(name, GetFunction(tpl).ToLocalChecked());
+  Set(recv, name, GetFunction(tpl).ToLocalChecked());
 }
 
 }  // end of namespace imp

nan_implementation_12_inl.h

@@ -100,9 +100,17 @@ Factory<v8::Function>::New( FunctionCallback callback
     obj->SetInternalField(imp::kDataIndex, val);
   }
 
-  return scope.Escape(v8::Function::New( isolate
-                          , imp::FunctionCallbackWrapper
-                          , obj));
+#if NODE_MAJOR_VERSION >= 10
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Function> function =
+      v8::Function::New(context, imp::FunctionCallbackWrapper, obj)
+      .ToLocalChecked();
+#else
+  v8::Local<v8::Function> function =
+      v8::Function::New(isolate, imp::FunctionCallbackWrapper, obj);
+#endif
+
+  return scope.Escape(function);
 }
 
 //=== Function Template ========================================================
@@ -332,12 +340,25 @@ Factory<v8::String>::New(ExternalOneByteStringResource * value) {
 
 //=== String Object ============================================================
 
+// See https://github.com/nodejs/nan/pull/811#discussion_r224594980.
+// Disable the warning as there is no way around it.
+// TODO(bnoordhuis) Use isolate-based version in Node.js v12.
 Factory<v8::StringObject>::return_t
 Factory<v8::StringObject>::New(v8::Local<v8::String> value) {
-#if V8_MAJOR_VERSION >= 7
-  return v8::StringObject::New(v8::Isolate::GetCurrent(), value).As<v8::StringObject>();
-#else
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
   return v8::StringObject::New(value).As<v8::StringObject>();
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+#ifdef _MSC_VER
+#pragma warning(pop)
 #endif
 }
 

nan_object_wrap.h

@@ -64,7 +64,10 @@ class ObjectWrap {
   inline void MakeWeak() {
     persistent().v8::PersistentBase<v8::Object>::SetWeak(
         this, WeakCallback, v8::WeakCallbackType::kParameter);
+#if NODE_MAJOR_VERSION < 10
+    // FIXME(bnoordhuis) Probably superfluous in older Node.js versions too.
     persistent().MarkIndependent();
+#endif
   }
 
 #elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION

test/cpp/accessors.cpp

@@ -61,7 +61,8 @@ NAN_MODULE_INIT(SetterGetter::Init) {
   );
 
   v8::Local<v8::Function> createnew =
-    Nan::New<v8::FunctionTemplate>(CreateNew)->GetFunction();
+    Nan::GetFunction(
+        Nan::New<v8::FunctionTemplate>(CreateNew)).ToLocalChecked();
   Set(target, Nan::New<v8::String>("create").ToLocalChecked(), createnew);
 }
 
@@ -70,7 +71,8 @@ v8::Local<v8::Value> SetterGetter::NewInstance () {
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(settergetter_constructor);
   v8::Local<v8::Object> instance =
-    Nan::NewInstance(constructorHandle->GetFunction()).ToLocalChecked();
+    Nan::NewInstance(
+        Nan::GetFunction(constructorHandle).ToLocalChecked()).ToLocalChecked();
   return scope.Escape(instance);
 }
 

test/cpp/accessors2.cpp

@@ -49,7 +49,8 @@ NAN_MODULE_INIT(SetterGetter::Init) {
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
   SetPrototypeMethod(tpl, "log", SetterGetter::Log);
   v8::Local<v8::Function> createnew =
-    Nan::New<v8::FunctionTemplate>(CreateNew)->GetFunction();
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(CreateNew))
+    .ToLocalChecked();
   Set(target, Nan::New<v8::String>("create").ToLocalChecked(), createnew);
 }
 
@@ -58,7 +59,8 @@ v8::Local<v8::Value> SetterGetter::NewInstance () {
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(settergetter_constructor);
   v8::Local<v8::Object> instance =
-    Nan::NewInstance(constructorHandle->GetFunction()).ToLocalChecked();
+    Nan::NewInstance(Nan::GetFunction(constructorHandle).ToLocalChecked())
+    .ToLocalChecked();
   SetAccessor(
       instance
     , Nan::New("prop1").ToLocalChecked()

test/cpp/asyncprogressqueueworker.cpp

@@ -55,7 +55,7 @@ NAN_METHOD(DoProgress) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("doProgress").ToLocalChecked()
-    , New<v8::FunctionTemplate>(DoProgress)->GetFunction());
+    , GetFunction(New<v8::FunctionTemplate>(DoProgress)).ToLocalChecked());
 }
 
 NODE_MODULE(asyncprogressqueueworker, Init)

test/cpp/asyncprogressqueueworkerstream.cpp

@@ -74,7 +74,7 @@ NAN_METHOD(DoProgress) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("doProgress").ToLocalChecked()
-    , New<v8::FunctionTemplate>(DoProgress)->GetFunction());
+    , GetFunction(New<v8::FunctionTemplate>(DoProgress)).ToLocalChecked());
 }
 
 NODE_MODULE(asyncprogressqueueworkerstream, Init)

test/cpp/asyncprogressworker.cpp

@@ -61,7 +61,7 @@ NAN_METHOD(DoProgress) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("a").ToLocalChecked()
-    , New<v8::FunctionTemplate>(DoProgress)->GetFunction());
+    , GetFunction(New<v8::FunctionTemplate>(DoProgress)).ToLocalChecked());
 }
 
 NODE_MODULE(asyncprogressworker, Init)

test/cpp/asyncprogressworkersignal.cpp

@@ -59,7 +59,7 @@ NAN_METHOD(DoProgress) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("a").ToLocalChecked()
-    , New<v8::FunctionTemplate>(DoProgress)->GetFunction());
+    , GetFunction(New<v8::FunctionTemplate>(DoProgress)).ToLocalChecked());
 }
 
 NODE_MODULE(asyncprogressworkersignal, Init)

test/cpp/asyncprogressworkerstream.cpp

@@ -81,7 +81,7 @@ NAN_METHOD(DoProgress) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("a").ToLocalChecked()
-    , New<v8::FunctionTemplate>(DoProgress)->GetFunction());
+    , GetFunction(New<v8::FunctionTemplate>(DoProgress)).ToLocalChecked());
 }
 
 NODE_MODULE(asyncprogressworkerstream, Init)

test/cpp/asyncworker.cpp

@@ -36,7 +36,7 @@ NAN_METHOD(DoSleep) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("a").ToLocalChecked()
-    , New<v8::FunctionTemplate>(DoSleep)->GetFunction());
+    , GetFunction(New<v8::FunctionTemplate>(DoSleep)).ToLocalChecked());
 }
 
 NODE_MODULE(asyncworker, Init)

test/cpp/asyncworkererror.cpp

@@ -29,7 +29,7 @@ NAN_METHOD(Work) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New("a").ToLocalChecked()
-    , New<v8::FunctionTemplate>(Work)->GetFunction());
+    , GetFunction(New<v8::FunctionTemplate>(Work)).ToLocalChecked());
 }
 
 NODE_MODULE(asyncworkererror, Init)

test/cpp/buffer.cpp

@@ -56,19 +56,19 @@ NAN_MODULE_INIT(Init) {
   }
   Set(target
     , New<v8::String>("new1").ToLocalChecked()
-    , New<v8::FunctionTemplate>(New1)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(New1)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("new2").ToLocalChecked()
-    , New<v8::FunctionTemplate>(New2)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(New2)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("new3").ToLocalChecked()
-    , New<v8::FunctionTemplate>(New3)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(New3)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("copy").ToLocalChecked()
-    , New<v8::FunctionTemplate>(Copy)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(Copy)).ToLocalChecked()
   );
 }
 

test/cpp/bufferworkerpersistent.cpp

@@ -61,7 +61,7 @@ NAN_METHOD(DoSleep) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("a").ToLocalChecked()
-    , New<v8::FunctionTemplate>(DoSleep)->GetFunction());
+    , GetFunction(New<v8::FunctionTemplate>(DoSleep)).ToLocalChecked());
 }
 
 NODE_MODULE(bufferworkerpersistent, Init)

test/cpp/converters.cpp

@@ -75,63 +75,63 @@ NAN_METHOD(Int32Value) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("toBoolean").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToBoolean)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToBoolean)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toNumber").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToNumber)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToNumber)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toString").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToString)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToString)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toDetailString").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToDetailString)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToDetailString)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toFunction").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToFunction)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToFunction)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toObject").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToObject)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToObject)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toInteger").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToInteger)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToInteger)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toUint32").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToUint32)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToUint32)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toInt32").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToInt32)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToInt32)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("toArrayIndex").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ToArrayIndex)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(ToArrayIndex)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("booleanValue").ToLocalChecked()
-    , New<v8::FunctionTemplate>(BooleanValue)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(BooleanValue)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("numberValue").ToLocalChecked()
-    , New<v8::FunctionTemplate>(NumberValue)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(NumberValue)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("integerValue").ToLocalChecked()
-    , New<v8::FunctionTemplate>(IntegerValue)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(IntegerValue)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("uint32Value").ToLocalChecked()
-    , New<v8::FunctionTemplate>(Uint32Value)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(Uint32Value)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("int32Value").ToLocalChecked()
-    , New<v8::FunctionTemplate>(Int32Value)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(Int32Value)).ToLocalChecked()
   );
 }
 

test/cpp/error.cpp

@@ -45,7 +45,7 @@ X(TypeError)
   Nan::Set(                                                                    \
       target                                                                   \
     , Nan::New(#NAME).ToLocalChecked()                                         \
-    , Nan::New<v8::FunctionTemplate>(NAME)->GetFunction());
+    , Nan::GetFunction(New<v8::FunctionTemplate>(NAME)).ToLocalChecked());
 
 
 NAN_MODULE_INIT(Init) {

test/cpp/gc.cpp

@@ -36,11 +36,11 @@ NAN_METHOD(Check) {
 NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("hook").ToLocalChecked()
-    , New<v8::FunctionTemplate>(Hook)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(Hook)).ToLocalChecked()
   );
   Set(target
     , New<v8::String>("check").ToLocalChecked()
-    , New<v8::FunctionTemplate>(Check)->GetFunction()
+    , GetFunction(New<v8::FunctionTemplate>(Check)).ToLocalChecked()
   );
 }
 

test/cpp/indexedinterceptors.cpp

@@ -50,7 +50,8 @@ NAN_MODULE_INIT(IndexedInterceptor::Init) {
     , IndexedInterceptor::PropertyEnumerator);
 
   v8::Local<v8::Function> createnew =
-    Nan::New<v8::FunctionTemplate>(CreateNew)->GetFunction();
+    Nan::GetFunction(Nan::New<v8::FunctionTemplate>(CreateNew))
+    .ToLocalChecked();
   Set(target, Nan::New("create").ToLocalChecked(), createnew);
 }
 
@@ -59,7 +60,8 @@ v8::Local<v8::Value> IndexedInterceptor::NewInstance () {
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(indexedinterceptors_constructor);
   v8::Local<v8::Object> instance =
-    Nan::NewInstance(constructorHandle->GetFunction()).ToLocalChecked();
+    Nan::NewInstance(Nan::GetFunction(constructorHandle).ToLocalChecked())
+    .ToLocalChecked();
   return scope.Escape(instance);
 }