Napi lock overhaul

Before, a reference to an environment was "proof" enough of a lock. Now,
an explicit lock witness class is used which also means we can carry
around additional lock state.

Author: laverdet

packages/auto_js/napi/CMakeLists.txt

@@ -20,6 +20,7 @@ target_sources(${napi_js}
 		support/environment.cc
 		support/host.cc
 		support/initialize.cc
+		support/lock.cc
 		transfer/accept.cc
 		value/array_buffer.cc
 		value/array.cc
@@ -35,6 +36,7 @@ target_sources(${napi_js}
 		api/invoke.cc
 		api/napi_scheduler.h.cc
 		api/threadsafe_function.cc
+		api/unmaybe.cc
 		api/uv_dlib.h.cc
 		api/uv_handle.cc
 		api/uv_scheduler.h.cc
@@ -51,6 +53,7 @@ target_sources(${napi_js}
 		support/error_scope.cc
 		support/host.h.cc
 		support/initialize.h.cc
+		support/lock.h.cc
 		support/promise.cc
 		support/string_table.cc
 		support/utility.cc

packages/auto_js/napi/_module.cc

@@ -11,6 +11,7 @@ export import :handle.local_of;
 export import :handle.types;
 export import :handle.value_of;
 export import :initialize;
+export import :lock;
 export import :promise;
 export import :reference;
 export import :remote;

packages/auto_js/napi/api/api.cc

@@ -8,6 +8,7 @@ export import :api.handle_scope;
 export import :api.invoke;
 export import :api.napi_scheduler;
 export import :api.threadsafe_function;
+export import :api.unmaybe;
 export import :api.uv_dlib;
 export import :api.uv_handle;
 export import :api.uv_scheduler;

packages/auto_js/napi/api/unmaybe.cc

@@ -0,0 +1,36 @@
+export module napi_js:api.unmaybe;
+import std;
+import v8;
+
+namespace js::napi {
+
+// Thrown from `unmaybe` to indicate that a direct v8 operation failed and there is an exception
+// waiting in the `v8::TryCatch` of the enclosing `environment_try_catch`.
+export class pending_v8_error : public std::exception {
+	public:
+		[[nodiscard]] auto what() const noexcept -> const char* final { return "[pending v8 error]"; }
+};
+
+// Unwrap a `MaybeLocal`, or throw `napi::pending_v8_error` on failure
+export template <class Type>
+auto unmaybe(v8::MaybeLocal<Type> maybe_value) -> v8::Local<Type> {
+	v8::Local<Type> value;
+	if (maybe_value.ToLocal(&value)) {
+		return value;
+	} else {
+		throw napi::pending_v8_error{};
+	}
+}
+
+// Unwrap a `Maybe`, or throw `napi::pending_v8_error` on failure
+export template <class Type>
+auto unmaybe(v8::Maybe<Type> maybe) -> Type {
+	Type value;
+	if (maybe.To(&value)) {
+		return value;
+	} else {
+		throw napi::pending_v8_error{};
+	}
+}
+
+} // namespace js::napi

packages/auto_js/napi/handle/remote.cc

@@ -1,5 +1,6 @@
 export module napi_js:remote;
 import :environment;
+import :lock;
 import :reference;
 import std;
 import util;
@@ -24,14 +25,16 @@ class remote : protected reference_handle {
 		using unique_remote = std::unique_ptr<remote, util::function_constant<expire>>;
 
 		remote() = default;
-		remote(private_constructor /*private*/, const environment& env, local_of<Tag> value, napi_scheduler scheduler) :
-				reference_handle{napi_env{env}, napi_value{value}},
+		remote(private_constructor /*private*/, environment_lock_witness lock, local_of<Tag> value, napi_scheduler scheduler) :
+				reference_handle{napi_env{lock}, napi_value{value}},
 				scheduler_{std::move(scheduler)} {}
 
-		auto deref(const environment& env) const -> local_of<Tag>;
+		auto deref(environment_lock_witness lock) const -> local_of<Tag>;
 
-		static auto make_shared(remote_handle_environment auto& env, local_of<Tag> value) -> std::shared_ptr<remote>;
-		static auto make_unique(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote;
+		template <remote_handle_environment Environment>
+		static auto make_shared(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> std::shared_ptr<remote>;
+		template <remote_handle_environment Environment>
+		static auto make_unique(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> unique_remote;
 
 	private:
 		napi_scheduler scheduler_;
@@ -44,14 +47,14 @@ using shared_remote = std::shared_ptr<remote<Type>>;
 export template <class Type>
 using unique_remote = remote<Type>::unique_remote;
 
-export template <class Tag>
-auto make_shared_remote(remote_handle_environment auto& env, local_of<Tag> value) -> shared_remote<Tag> {
-	return remote<Tag>::make_shared(env, value);
+export template <remote_handle_environment Environment, class Tag>
+auto make_shared_remote(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> shared_remote<Tag> {
+	return remote<Tag>::make_shared(lock, value);
 }
 
-export template <class Tag>
-auto make_unique_remote(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote<Tag> {
-	return remote<Tag>::make_unique(env, value);
+export template <remote_handle_environment Environment, class Tag>
+auto make_unique_remote(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> unique_remote<Tag> {
+	return remote<Tag>::make_unique(lock, value);
 }
 
 // ---
@@ -68,18 +71,20 @@ auto remote<Tag>::expire(remote* ptr) -> void {
 }
 
 template <class Tag>
-auto remote<Tag>::deref(const environment& env) const -> local_of<Tag> {
-	return local_of<Tag>::from(get_value(napi_env{env}));
+auto remote<Tag>::deref(environment_lock_witness lock) const -> local_of<Tag> {
+	return local_of<Tag>::from(get_value(napi_env{lock}));
 }
 
 template <class Tag>
-auto remote<Tag>::make_shared(remote_handle_environment auto& env, local_of<Tag> value) -> std::shared_ptr<remote> {
-	return std::shared_ptr<remote>{new remote{private_constructor{}, env, value, env.scheduler()}, expire};
+template <remote_handle_environment Environment>
+auto remote<Tag>::make_shared(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> std::shared_ptr<remote> {
+	return std::shared_ptr<remote>{new remote{private_constructor{}, lock, value, lock->scheduler()}, expire};
 }
 
 template <class Tag>
-auto remote<Tag>::make_unique(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote {
-	return unique_remote{new remote{private_constructor{}, env, value, env.scheduler()}};
+template <remote_handle_environment Environment>
+auto remote<Tag>::make_unique(const environment_lock_witness_of<Environment>& lock, local_of<Tag> value) -> unique_remote {
+	return unique_remote{new remote{private_constructor{}, lock, value, lock->scheduler()}};
 }
 
 } // namespace js::napi

packages/auto_js/napi/handle/value.cc

@@ -1,7 +1,9 @@
 export module napi_js:handle.value_of;
 import :handle.types;
+import :lock;
 import nodejs;
 import std;
+import v8;
 
 namespace js::napi {
 
@@ -33,7 +35,7 @@ class value_next : public value_of<typename Tag::tag_type> {
 };
 
 // Member & method implementation for value semantics objects. It holds the type-erased environment
-// and is used for common operations like casting & iteration.
+// lock witness and is used for common operations like casting & iteration.
 template <class Tag>
 class value_of : public value_specialization<Tag>::type {
 	public:
@@ -46,14 +48,19 @@ template <>
 class value_of<void> : public runtime_handle {
 	protected:
 		value_of() = default;
-		value_of(napi_env env, napi_value value) :
+		value_of(environment_lock_witness lock, napi_value value) :
 				runtime_handle{value},
-				env_{env} {}
+				env_{lock},
+				isolate_{lock.isolate()},
+				context_{lock.context()} {}
 
 		[[nodiscard]] auto env() const -> napi_env { return env_; }
+		[[nodiscard]] auto lock() const -> environment_lock_witness { return environment_lock_witness::make_witness(env_, isolate_, context_); }
 
 	private:
 		napi_env env_{};
+		v8::Isolate* isolate_{};
+		v8::Local<v8::Context> context_;
 };
 
 // Deduction guide