@auto_js/napi 0.0.7 → 0.0.9

package/handle/types.cc

@@ -4,14 +4,13 @@ import nodejs;
 
 namespace js::napi {
 
-// `value_handle` is the base class of `value_of<T>`, and `bound_value<T>`.
-class value_handle {
+// `runtime_handle` is the base class of `local_of<T>` and `value_of<T>` member types.
+class runtime_handle {
 	protected:
-		explicit value_handle(napi_value value) :
-				value_{value} {}
-
 	public:
-		value_handle() = default;
+		explicit runtime_handle(int, napi_value value) : value_{value} {}
+		explicit runtime_handle(napi_value value) : value_{value} {}
+		runtime_handle() = default;
 
 		// Implicit cast back to a `napi_value`
 		// NOLINTNEXTLINE(google-explicit-constructor)
@@ -24,133 +23,11 @@ class value_handle {
 		napi_value value_{};
 };
 
-// `value_of` forward declarations
+// Forward declarations for handle types which declare template deduction guides on each other.
 export template <class Tag = value_tag>
-class value_of;
-
-template <class Tag>
-class value_next;
-
-template <class Type>
-class value_for_class_of;
-
-template <class Type>
-class value_for_typed_array_of;
-
-// `bound_value` forward declarations
-template <class Tag>
-class bound_value;
-
-template <class Tag>
-class bound_value_next;
-
-template <class Type>
-class bound_value_for_typed_array_of;
-
-// Map of `value_of<Tag>` / `bound_value<Tag>` to concrete implementation classes.
-template <class Tag>
-struct value_defaults {
-		using value_type = value_next<Tag>;
-		using bound_type = bound_value_next<Tag>;
-};
-
-template <class Tag>
-struct value_specialization : value_defaults<Tag> {};
-
-// Typed specializations
-template <>
-struct value_specialization<boolean_tag> : value_defaults<boolean_tag> {
-		using bound_type = class bound_value_for_boolean;
-};
-
-template <>
-struct value_specialization<number_tag> : value_defaults<number_tag> {
-		using bound_type = class bound_value_for_number;
-};
-
-template <>
-struct value_specialization<bigint_tag> : value_defaults<bigint_tag> {
-		using bound_type = class bound_value_for_bigint;
-};
-
-template <>
-struct value_specialization<string_tag> : value_defaults<string_tag> {
-		using bound_type = class bound_value_for_string;
-};
-
-template <>
-struct value_specialization<date_tag> : value_defaults<date_tag> {
-		using bound_type = class bound_value_for_date;
-};
-
-template <>
-struct value_specialization<object_tag> {
-		using value_type = class value_for_object;
-		using bound_type = class bound_value_for_object;
-};
-
-template <>
-struct value_specialization<record_tag> : value_defaults<record_tag> {
-		using bound_type = class bound_value_for_record;
-};
-
-template <>
-struct value_specialization<function_tag> : value_defaults<function_tag> {
-		using value_type = class value_for_function;
-};
-
-template <>
-struct value_specialization<data_block_tag> : value_defaults<data_block_tag> {
-		using bound_type = class bound_value_for_data_block;
-};
-
-template <>
-struct value_specialization<array_buffer_tag> : value_defaults<array_buffer_tag> {
-		using bound_type = class bound_value_for_array_buffer;
-};
-
-template <>
-struct value_specialization<shared_array_buffer_tag> : value_defaults<shared_array_buffer_tag> {
-		using bound_type = class bound_value_for_shared_array_buffer;
-};
-
-template <>
-struct value_specialization<array_buffer_view_tag> : value_defaults<array_buffer_view_tag> {
-		using bound_type = class bound_value_for_array_buffer_view;
-};
-
-template <>
-struct value_specialization<typed_array_tag> {
-		using value_type = class value_for_typed_array;
-		using bound_type = class bound_value_for_typed_array;
-};
-
-template <class Type>
-struct value_specialization<typed_array_tag_of<Type>> {
-		using value_type = value_for_typed_array_of<Type>;
-		using bound_type = bound_value_for_typed_array_of<Type>;
-};
-
-template <>
-struct value_specialization<data_view_tag> {
-		using value_type = class value_for_data_view;
-		using bound_type = class bound_value_for_data_view;
-};
-
-template <class Type>
-struct value_specialization<class_tag_of<Type>> : value_defaults<class_tag_of<Type>> {
-		using value_type = value_for_class_of<Type>;
-};
-
-template <>
-struct value_specialization<external_tag> {
-		using value_type = class value_for_external;
-		using bound_type = class bound_value_for_external;
-};
+class local_of;
 
-template <>
-struct value_specialization<vector_tag> : value_defaults<vector_tag> {
-		using bound_type = class bound_value_for_vector;
-};
+export template <class Tag = value_tag>
+class value_of;
 
 } // namespace js::napi

package/handle/value.cc

@@ -1,55 +1,147 @@
-export module napi_js:value_handle;
+export module napi_js:handle.value_of;
 import :handle.types;
-import auto_js;
 import nodejs;
 import std;
 
 namespace js::napi {
 
-// Heirarchy:
-// value_of<object_tag> ->
+// Map of `value_of<Tag>` to concrete implementation classes.
+template <class Tag>
+struct value_specialization;
+
+// Heirarchy (for example):
+// value_of<record_tag>
+// value_for_record ->
+// value_next<record_tag> ->
 // value_for_object ->
 // value_next<object_tag> ->
-// value_of<value_tag> -> ...
+// value_next<value_tag> ->
+// value_next<datum_tag> ->
+// value_of<void>
 
 // Details applied to each level of the `value_of<T>` hierarchy.
 template <class Tag>
 class value_next : public value_of<typename Tag::tag_type> {
 	public:
-		using value_of<typename Tag::tag_type>::value_of;
+		using tag_type = Tag;
+		value_next() = default;
+		value_next(auto&& env, local_of<Tag> value, auto&&... rest) :
+				value_of<typename Tag::tag_type>{std::forward<decltype(env)>(env), value, std::forward<decltype(rest)>(rest)...} {}
 
-		// "Downcast" to a more specific tag. Potentially unsafe.
-		template <std::convertible_to<Tag> To>
-		auto cast(To /*tag*/) const -> value_of<To> { return value_of<To>::from(*this); }
-
-		// Construct from any `napi_value`. Potentially unsafe.
-		static auto from(napi_value value_) -> value_of<Tag> { return std::bit_cast<value_of<Tag>>(value_); }
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		operator local_of<Tag>() const { return local_of<Tag>::from(napi_value{*this}); }
 };
 
-// Deduction guide for `value_of{bound_value}`
-template <class Type>
-	requires requires { typename Type::tag_type; }
-value_of(Type value) -> value_of<typename Type::tag_type>;
-
-// Tagged napi_value
-export template <class Tag>
-class value_of : public value_specialization<Tag>::value_type {
+// Member & method implementation for value semantics objects. It holds the type-erased environment
+// and is used for common operations like casting & iteration.
+template <class Tag>
+class value_of : public value_specialization<Tag>::type {
 	public:
-		using value_specialization<Tag>::value_type::value_type;
+		using value_type = value_specialization<Tag>::type;
+		using value_type::value_type;
 };
 
 // Sentinel instantiation
 template <>
-class value_of<void> : public value_handle {
-	public:
-		using value_handle::value_handle;
+class value_of<void> : public runtime_handle {
+	protected:
+		value_of() = default;
+		value_of(napi_env env, napi_value value) :
+				runtime_handle{value},
+				env_{env} {}
+
+		[[nodiscard]] auto env() const -> napi_env { return env_; }
+
+	private:
+		napi_env env_{};
 };
 
-} // namespace js::napi
+// Deduction guide
+template <class Tag>
+value_of(auto, local_of<Tag>) -> value_of<Tag>;
+
+// `value_of<Tag>` specializations. The default specialization selects `value_next` for the
+// immediate parent tag, instantiating it for each tag unconditionally.
+template <class Type> class value_for_typed_array_of;
 
-// Specialize for `js::forward`. Makes `js::forward{value_of<Tag>}` infer
-// `js::forward<Tag, ...>`.
-namespace js {
 template <class Tag>
-struct forward_tag_for<napi::value_of<Tag>> : std::type_identity<Tag> {};
-} // namespace js
+struct value_specialization
+		: std::type_identity<value_next<Tag>> {};
+
+template <>
+struct value_specialization<void>
+		: std::type_identity<value_of<void>> {};
+
+template <>
+struct value_specialization<boolean_tag>
+		: std::type_identity<class value_for_boolean> {};
+
+template <>
+struct value_specialization<false_tag>
+		: std::type_identity<class value_for_false> {};
+
+template <>
+struct value_specialization<true_tag>
+		: std::type_identity<class value_for_true> {};
+
+template <>
+struct value_specialization<number_tag>
+		: std::type_identity<class value_for_number> {};
+
+template <>
+struct value_specialization<bigint_tag>
+		: std::type_identity<class value_for_bigint> {};
+
+template <>
+struct value_specialization<string_tag>
+		: std::type_identity<class value_for_string> {};
+
+template <>
+struct value_specialization<object_tag>
+		: std::type_identity<class value_for_object> {};
+
+template <>
+struct value_specialization<date_tag>
+		: std::type_identity<class value_for_date> {};
+
+template <>
+struct value_specialization<record_tag>
+		: std::type_identity<class value_for_record> {};
+
+template <>
+struct value_specialization<data_block_tag>
+		: std::type_identity<class value_for_data_block> {};
+
+template <>
+struct value_specialization<array_buffer_tag>
+		: std::type_identity<class value_for_array_buffer> {};
+
+template <>
+struct value_specialization<shared_array_buffer_tag>
+		: std::type_identity<class value_for_shared_array_buffer> {};
+
+template <>
+struct value_specialization<array_buffer_view_tag>
+		: std::type_identity<class value_for_array_buffer_view> {};
+
+template <>
+struct value_specialization<typed_array_tag>
+		: std::type_identity<class value_for_typed_array> {};
+
+template <class Type>
+struct value_specialization<typed_array_tag_of<Type>>
+		: std::type_identity<value_for_typed_array_of<Type>> {};
+
+template <>
+struct value_specialization<data_view_tag>
+		: std::type_identity<class value_for_data_view> {};
+
+template <>
+struct value_specialization<external_tag>
+		: std::type_identity<class value_for_external> {};
+
+template <>
+struct value_specialization<vector_tag>
+		: std::type_identity<class value_for_vector> {};
+
+} // namespace js::napi

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@auto_js/napi",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "author": "https://github.com/laverdet/",
   "description": "Automatic JavaScript to N-API bindings",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/napi",
   "license": "ISC",
   "dependencies": {
-    "@auto_js/js": "^0.0.7",
-    "@auto_js/napi_exports": "^0.0.7",
-    "@auto_js/v8_exports": "^0.0.5"
+    "@auto_js/v8_exports": "^0.0.7",
+    "@auto_js/js": "^0.0.9",
+    "@auto_js/napi_exports": "^0.0.9"
   },
   "repository": {
     "type": "git",

package/support/callback.cc

@@ -13,7 +13,7 @@ template <class Type>
 constexpr auto unwrap_member_this = [](auto_environment auto& env, napi_value this_arg) noexcept -> std::optional<tagged_external<Type>> {
 	return napi::invoke_maybe(napi_coerce_to_object, napi_env{env}, this_arg)
 		.and_then([ &env ](napi_value coerced_this_arg) -> std::optional<tagged_external<Type>> {
-			auto as_object = bound_value{env, value_of<object_tag>::from(coerced_this_arg)};
+			auto as_object = value_of{env, local_of<object_tag>::from(coerced_this_arg)};
 			// Technically `try_cast` can throw but it should only be in catastrophic cases.
 			Type* unwrapped = as_object.try_cast(type<Type>);
 			if (unwrapped == nullptr) {
@@ -116,7 +116,7 @@ constexpr auto make_constructor_function(auto constructor) {
 							auto instance = std::apply(
 								callback,
 								std::tuple_cat(
-									std::forward_as_tuple(env, value_of<object_tag>::from(info.this_arg())),
+									std::forward_as_tuple(env, local_of<object_tag>::from(info.this_arg())),
 									js::transfer_out<std::tuple<js::functional::parameter_transfer_as_t<Args>...>>(info.arguments(), env)
 								)
 							);
@@ -136,7 +136,7 @@ constexpr auto make_constructor_function(auto constructor) {
 				using callback_type = decltype(callback);
 				return util::bind{
 					[](callback_type& callback, Environment& env, const callback_info& info) noexcept -> napi_value {
-						return wrap(callback(env, value_of<object_tag>::from(info.this_arg())));
+						return wrap(callback(env, local_of<object_tag>::from(info.this_arg())));
 					},
 					std::move(callback),
 				};

package/support/callback_storage.cc

@@ -35,12 +35,12 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 			// Trivial function type containing less than or equal to a pointer size. `data` is the
 			// function and environment is stored in a thread local.
 			callback_env_local<Environment> = &env;
-			auto* data = reinterpret_cast<void*&>(function);
+			auto* data = util::bit_padding_cast<void*>(function);
 			const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
 				const auto args = callback_info{nenv, info};
 				if (args) {
 					auto* data = args.data();
-					auto& invoke = reinterpret_cast<function_type&>(data);
+					auto invoke = util::bit_truncation_cast<function_type>(data);
 					auto& env = *callback_env_local<Environment>;
 					return invoke(env, args);
 				} else {

package/support/class_template_storage.cc

@@ -20,7 +20,7 @@ export template <const auto& Strings>
 class class_template_references {
 	public:
 		template <class Type>
-		auto class_template(this auto& self, std::type_identity<Type> /*type*/, const auto& class_template) -> value_of<class_tag_of<Type>> {
+		auto class_template(this auto& self, std::type_identity<Type> /*type*/, const auto& class_template) -> local_of<class_tag_of<Type>> {
 			constexpr auto name_sv = util::make_consteval_string_view(class_template.constructor.name);
 			constexpr auto index = class_template_references_of<Strings>.lookup(name_sv);
 			if constexpr (!index) {
@@ -33,7 +33,7 @@ class class_template_references {
 				static_assert(index, "Class template '"s + name_sv + "' is missing in storage"s);
 			}
 			auto& reference = self.class_template_references_.at(index).second;
-			using value_type = js::napi::value_of<class_tag_of<Type>>;
+			using value_type = js::napi::local_of<class_tag_of<Type>>;
 			if (reference) {
 				return value_type::from(reference.get(self));
 			} else {