Update for nodejs v24

Fixes #531

Author: laverdet

binding.gyp

@@ -3,18 +3,18 @@
 		'default_configuration': 'Release',
 		'configurations': {
 			'Common': {
-				'cflags_cc': [ '-std=c++17', '-g', '-Wno-unknown-pragmas' ],
+				'cflags_cc': [ '-std=c++20', '-g', '-Wno-unknown-pragmas' ],
 				'cflags_cc!': [ '-fno-exceptions' ],
 				'include_dirs': [ './src', './vendor' ],
 				'xcode_settings': {
 					'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
 					'GCC_GENERATE_DEBUGGING_SYMBOLS': 'YES',
-					'CLANG_CXX_LANGUAGE_STANDARD': 'c++17',
+					'CLANG_CXX_LANGUAGE_STANDARD': 'c++20',
 					'MACOSX_DEPLOYMENT_TARGET': '10.12',
 				},
 				'msvs_settings': {
 					'VCCLCompilerTool': {
-						'AdditionalOptions': [ '-std:c++17', '/GR' ],
+						'AdditionalOptions': [ '-std:c++20', '/GR' ],
 						'ExceptionHandling': '1',
 					},
 				},

src/isolate/allocator.h

@@ -13,14 +13,12 @@ class LimitedAllocator : public v8::ArrayBuffer::Allocator {
 		size_t next_check;
 		int failures = 0;
 
-
 	public:
 		auto Check(size_t length) -> bool;
 		explicit LimitedAllocator(class IsolateEnvironment& env, size_t limit);
 		auto Allocate(size_t length) -> void* final;
 		auto AllocateUninitialized(size_t length) -> void* final;
 		void Free(void* data, size_t length) final;
-		auto Reallocate(void* data, size_t old_length, size_t new_length) -> void* final;
 
 		// This is used by ExternalCopy when an ArrayBuffer is transferred. The memory is not freed but
 		// we should no longer count it against the isolate

src/isolate/allocator_nortti.cc

@@ -115,17 +115,6 @@ void LimitedAllocator::Free(void* data, size_t length) {
 	std::free(data);
 }
 
-auto LimitedAllocator::Reallocate(void* data, size_t old_length, size_t new_length) -> void* {
-	auto delta = static_cast<ssize_t>(new_length) - static_cast<ssize_t>(old_length);
-	if (delta > 0) {
-		if (!Check(delta)) {
-			return nullptr;
-		}
-	}
-	env.extra_allocated_memory += delta;
-	return ArrayBuffer::Allocator::Reallocate(data, old_length, new_length);
-}
-
 void LimitedAllocator::AdjustAllocatedSize(ptrdiff_t length) {
 	env.extra_allocated_memory += length;
 }

src/isolate/class_handle.h

@@ -92,7 +92,7 @@ class ClassHandle {
 			template <typename... Args>
 			void Add(const char* name, detail::MemberAccessorHolder impl, Args... args) {
 				v8::Local<v8::String> name_handle = v8_symbol(name);
-				proto->SetAccessor(name_handle, impl.getter.callback, impl.setter.callback);
+				proto->SetNativeDataProperty(name_handle, impl.getter.callback, impl.setter.callback);
 				Add(args...);
 			}
 

src/isolate/environment.h

@@ -108,7 +108,7 @@ class IsolateEnvironment {
 		std::atomic<unsigned int> remotes_count{0};
 		v8::HeapStatistics last_heap {};
 		// Copyable traits used to opt into destructor handle reset
-		std::deque<v8::Persistent<v8::Promise, v8::CopyablePersistentTraits<v8::Promise>>> unhandled_promise_rejections;
+		std::deque<v8::Global<v8::Promise>> unhandled_promise_rejections;
 		StringTable string_table;
 
 		std::vector<v8::Eternal<v8::Data>> specifics;

src/isolate/holder.cc

@@ -63,14 +63,14 @@ void IsolateHolder::ScheduleTask(std::unique_ptr<Runnable> task, bool run_inline
 }
 
 // Methods for v8::TaskRunner
-void IsolateTaskRunner::PostTask(std::unique_ptr<v8::Task> task) {
+void IsolateTaskRunner::PostTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& /*location*/) {
 	auto env = weak_env.lock();
 	if (env) {
 		env->GetScheduler().Lock()->tasks.push(std::move(task));
 	}
 }
 
-void IsolateTaskRunner::PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) {
+void IsolateTaskRunner::PostDelayedTaskImpl(std::unique_ptr<v8::Task> task, double delay_in_seconds, const v8::SourceLocation& /*location*/) {
 	// wait_detached erases the type of the lambda into a std::function which must be
 	// copyable. The unique_ptr is stored in a shared pointer so ownership can be handled correctly.
 	auto shared_task = std::make_shared<std::unique_ptr<v8::Task>>(std::move(task));

src/isolate/holder.h

@@ -52,9 +52,9 @@ class IsolateTaskRunner final : public TaskRunner {
 		auto operator=(const IsolateTaskRunner&) = delete;
 
 		// Methods for v8::TaskRunner
-		void PostTask(std::unique_ptr<v8::Task> task) final;
-		void PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) final;
-		void PostNonNestableTask(std::unique_ptr<v8::Task> task) final { PostTask(std::move(task)); }
+		void PostTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& /*location*/) final;
+		void PostDelayedTaskImpl(std::unique_ptr<v8::Task> task, double delay_in_seconds, const v8::SourceLocation& /*location*/) final;
+		void PostNonNestableTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& /*location*/) final { PostTask(std::move(task)); }
 
 	private:
 		std::weak_ptr<IsolateEnvironment> weak_env;

src/isolate/platform_delegate.h

@@ -12,13 +12,13 @@ namespace ivm {
 class TaskRunner : public v8::TaskRunner {
 	public:
 		// Methods for v8::TaskRunner
-		void PostTask(std::unique_ptr<v8::Task> task) override = 0;
-		void PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) override = 0;
-		void PostIdleTask(std::unique_ptr<v8::IdleTask> /*task*/) final { std::terminate(); }
+		void PostTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& location) override = 0;
+		void PostDelayedTaskImpl(std::unique_ptr<v8::Task> task, double delay_in_seconds, const v8::SourceLocation& location) override = 0;
+		void PostIdleTaskImpl(std::unique_ptr<v8::IdleTask> /*task*/, const v8::SourceLocation& /*location*/) final { std::terminate(); }
 		// Can't be final because symbol is also used in IsolatePlatformDelegate
 		auto IdleTasksEnabled() -> bool override { return false; };
 		auto NonNestableTasksEnabled() const -> bool final { return true; }
-		void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> /*task*/, double /*delay_in_seconds*/) final { std::terminate(); }
+		// void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> /*task*/, double /*delay_in_seconds*/) final { std::terminate(); }
 		auto NonNestableDelayedTasksEnabled() const -> bool final { return false; }
 };
 

src/isolate/remote_handle.h

@@ -17,7 +17,7 @@ namespace detail {
 template <size_t Index, class Type>
 struct HandleTupleElement {
 	HandleTupleElement(v8::Isolate* isolate, v8::Local<Type> local) : persistent{isolate, local} {}
-	v8::Persistent<Type, v8::NonCopyablePersistentTraits<Type>> persistent;
+	v8::Persistent<Type> persistent;
 };
 
 template <class Indices, class ...Types>

src/isolate/stack_trace.cc

@@ -100,12 +100,11 @@ void ErrorStackGetter(Local<Name> /*property*/, const PropertyCallbackInfo<Value
 void AttachStackGetter(Local<Object> error, Local<Value> data) {
 	Local<Context> context = Isolate::GetCurrent()->GetCurrentContext();
 	Unmaybe(error->SetPrivate(context, GetPrivateStackSymbol(), data));
-	Unmaybe(error->SetAccessor(
+	Unmaybe(error->SetNativeDataProperty(
 		context,
 		StringTable::Get().stack,
 		ErrorStackGetter, nullptr,
 		Local<Value>(),
-		AccessControl::DEFAULT,
 		PropertyAttribute::DontEnum
 	));
 }