@isolated-vm/experimental 0.0.9 → 0.0.11

package/addon/CMakeLists.txt

@@ -7,7 +7,7 @@ target_link_libraries(isolated_vm PRIVATE ${auto_js} utility_js)
 target_sources(isolated_vm
 	PUBLIC FILE_SET CXX_MODULES FILES
 		_module.cc
-		handle/bound_value.cc
+		handle/local_of.cc
 		handle/types.cc
 		handle/value_of.cc
 		support/callback_info.cc

package/addon/handle/local_of.cc

@@ -0,0 +1,149 @@
+export module isolated_vm:handle.local_of;
+export import :handle.types;
+import auto_js;
+import std;
+import util;
+
+namespace isolated_vm {
+using namespace js;
+
+// Map of `local_of<Tag>` to its concrete implementation class
+template <class Tag>
+struct local_specialization;
+
+// Tagged isolated_vm value. Each `local_of<T>` inherits from the tag before it.
+export template <class Tag>
+class local_of : public local_of<typename Tag::tag_type> {
+	private:
+		using local_type = local_specialization<Tag>::type;
+
+	public:
+		local_of() = default;
+		using tag_type = Tag;
+
+		// Constructor from tagged `runtime_handle` flavors
+		explicit local_of(local_type value)
+			requires(type<local_type> != type<runtime_handle>) :
+				local_of{runtime_handle{value}} {}
+
+		// "Downcast" to a more specific tag. Potentially unsafe.
+		template <std::convertible_to<Tag> To>
+		auto cast(To /*tag*/) const -> local_of<To> { return local_of<To>::from(*this); }
+
+		// Construct from any `value_handle`. Potentially unsafe.
+		static auto from(runtime_handle value_) -> local_of<Tag> { return std::bit_cast<local_of<Tag>>(value_); }
+
+		// Forward `make` to specialization
+		static auto make(auto&&... args) -> local_of<Tag> { return local_type::make(std::forward<decltype(args)>(args)...); }
+
+		// Dereference operators
+		auto operator*() const -> local_type { return std::bit_cast<local_type>(runtime_handle{*this}); }
+		auto operator->() const -> auto { return util::pointer_delegate{**this}; }
+};
+
+// Sentinel instantiation
+template <>
+class local_of<void> : public runtime_handle {
+	public:
+		using runtime_handle::runtime_handle;
+		explicit local_of(runtime_handle value) : runtime_handle{value} {}
+		local_of() = default;
+};
+
+// Deduction guide
+template <class Type>
+local_of(Type value) -> local_of<typename Type::tag_type>;
+
+// Details applied to each level of the `local_of<T>` hierarchy.
+template <class Tag>
+struct local_next : local_specialization<typename Tag::tag_type>::type {
+		using local_specialization<typename Tag::tag_type>::type::type;
+		using tag_type = Tag;
+};
+
+// `local_of<Tag>` implementation specializations. The default specialization selects the nearest
+// specialization, or simply `runtime_handle` as the base class.
+template <class Tag>
+struct local_specialization
+		: local_specialization<typename Tag::tag_type> {};
+
+template <>
+struct local_specialization<void>
+		: std::type_identity<runtime_handle> {};
+
+template <>
+struct local_specialization<value_tag>
+		: std::type_identity<class local_for_value> {};
+
+template <>
+struct local_specialization<primitive_tag>
+		: std::type_identity<class local_for_primitive> {};
+
+template <>
+struct local_specialization<undefined_tag>
+		: std::type_identity<class local_for_undefined> {};
+
+template <>
+struct local_specialization<null_tag>
+		: std::type_identity<class local_for_null> {};
+
+template <>
+struct local_specialization<boolean_tag>
+		: std::type_identity<class local_for_boolean> {};
+
+template <>
+struct local_specialization<number_tag>
+		: std::type_identity<class local_for_number> {};
+
+template <>
+struct local_specialization<name_tag>
+		: std::type_identity<class local_for_name> {};
+
+template <>
+struct local_specialization<string_tag>
+		: std::type_identity<class local_for_string> {};
+
+template <>
+struct local_specialization<bigint_tag>
+		: std::type_identity<class local_for_bigint> {};
+
+template <>
+struct local_specialization<function_tag>
+		: std::type_identity<class local_for_function> {};
+
+template <>
+struct local_specialization<object_tag>
+		: std::type_identity<class local_for_object> {};
+
+template <>
+struct local_specialization<record_tag>
+		: std::type_identity<class local_for_record> {};
+
+template <>
+struct local_specialization<list_tag>
+		: std::type_identity<class local_for_array> {};
+
+template <>
+struct local_specialization<data_block_tag>
+		: std::type_identity<class local_for_data_block> {};
+
+template <>
+struct local_specialization<array_buffer_tag>
+		: std::type_identity<class local_for_array_buffer> {};
+
+template <>
+struct local_specialization<array_buffer_view_tag>
+		: std::type_identity<class local_for_array_buffer_view> {};
+
+template <>
+struct local_specialization<prototype_tag>
+		: std::type_identity<class local_for_prototype> {};
+
+} // namespace isolated_vm
+
+// Specialize for `js::forward`. Makes `js::forward{local_of<Tag>}` infer
+// `js::forward<Tag, ...>`.
+namespace js {
+template <class Tag>
+struct forward_tag_for<isolated_vm::local_of<Tag>> : std::type_identity<Tag> {};
+} // namespace js

package/addon/handle/types.cc

@@ -4,13 +4,11 @@ import auto_js;
 namespace isolated_vm {
 using namespace js;
 
-// `value_handle` is the base class of `value_of<T>`, and `bound_value<T>`.
-class value_handle {
-	protected:
-		explicit value_handle(void* value) : value_{value} {}
-
+// `runtime_handle` is the base class of `local_of<T>` and `value_of<T>` member types.
+class runtime_handle {
 	public:
-		value_handle() = default;
+		explicit runtime_handle(void* value) : value_{value} {}
+		runtime_handle() = default;
 
 		// Check empty value
 		explicit operator bool() const { return value_ != nullptr; }
@@ -19,138 +17,11 @@ class value_handle {
 		void* 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;
-
-// `bound_value` forward declarations
-export 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 bound_type = bound_value_next<Tag>;
-		using value_type = value_next<Tag>;
-};
-
-template <class Tag>
-struct value_specialization : value_defaults<Tag> {};
-
-// Typed specializations
-template <>
-struct value_specialization<value_tag> : value_defaults<value_tag> {
-		using value_type = class value_for_value;
-};
-
-template <>
-struct value_specialization<primitive_tag> : value_defaults<primitive_tag> {
-		using value_type = class value_for_primitive;
-};
-
-template <>
-struct value_specialization<undefined_tag> : value_defaults<undefined_tag> {
-		using value_type = class value_for_undefined;
-};
-
-template <>
-struct value_specialization<null_tag> : value_defaults<null_tag> {
-		using value_type = class value_for_null;
-};
-
-template <>
-struct value_specialization<boolean_tag> : value_defaults<boolean_tag> {
-		using bound_type = class bound_value_for_boolean;
-		using value_type = class value_for_boolean;
-};
-
-template <>
-struct value_specialization<number_tag> : value_defaults<number_tag> {
-		using bound_type = class bound_value_for_number;
-		using value_type = class value_for_number;
-};
-
-template <>
-struct value_specialization<name_tag> : value_defaults<name_tag> {
-		using value_type = class value_for_name;
-};
-
-template <>
-struct value_specialization<string_tag> : value_defaults<string_tag> {
-		using bound_type = class bound_value_for_string;
-		using value_type = class value_for_string;
-};
+class local_of;
 
-template <>
-struct value_specialization<bigint_tag> : value_defaults<bigint_tag> {
-		using bound_type = class bound_value_for_bigint;
-		using value_type = class value_for_bigint;
-};
-
-template <>
-struct value_specialization<function_tag> : value_defaults<function_tag> {
-		using value_type = class value_for_function;
-};
-
-template <>
-struct value_specialization<object_tag> : value_defaults<object_tag> {
-		using value_type = class value_for_object;
-};
-
-template <>
-struct value_specialization<record_tag> : value_defaults<record_tag> {
-		using bound_type = class bound_value_for_record;
-		using value_type = class value_for_record;
-};
-
-template <>
-struct value_specialization<list_tag> : value_defaults<list_tag> {
-		using value_type = class value_for_array;
-};
-
-template <>
-struct value_specialization<vector_tag> : value_defaults<vector_tag> {
-		using bound_type = class bound_value_for_vector;
-};
-
-template <>
-struct value_specialization<data_block_tag> : value_defaults<data_block_tag> {
-		using bound_type = class bound_value_for_data_block;
-		using value_type = class value_for_data_block;
-};
-
-template <>
-struct value_specialization<array_buffer_tag> : value_defaults<array_buffer_tag> {
-		using value_type = class value_for_array_buffer;
-};
-
-template <>
-struct value_specialization<array_buffer_view_tag> : value_defaults<array_buffer_view_tag> {
-		using value_type = class value_for_array_buffer_view;
-};
-
-template <>
-struct value_specialization<data_view_tag> : value_defaults<data_view_tag> {
-		using bound_type = bound_value_for_typed_array_of<void>;
-};
-
-template <class Type>
-struct value_specialization<typed_array_tag_of<Type>> : value_defaults<typed_array_tag_of<Type>> {
-		using bound_type = bound_value_for_typed_array_of<Type>;
-};
-
-template <>
-struct value_specialization<prototype_tag> : value_defaults<prototype_tag> {
-		using value_type = class value_for_prototype;
-};
+export template <class Tag = value_tag>
+class value_of;
 
 } // namespace isolated_vm

package/addon/handle/value_of.cc

@@ -1,47 +1,102 @@
 export module isolated_vm:handle.value_of;
-export import :handle.types;
+import :handle.types;
+import :support.lock_fwd;
 import auto_js;
 import std;
 
 namespace isolated_vm {
 using namespace js;
 
-// Details applied to each level of the `value_of<T>` hierarchy.
+// Map of `value_of<Tag>` to concrete implementation classes.
 template <class Tag>
-class value_next : public value_of<typename Tag::tag_type> {
+struct value_specialization;
+
+// Member & method implementation for stateful objects. Used internally in visitors.
+template <class Tag>
+class value_of : public value_specialization<Tag>::type {
 	public:
-		using value_of<typename Tag::tag_type>::value_of;
+		using value_type = value_specialization<Tag>::type;
+		using value_type::value_type;
+};
 
-		// "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); }
+// Sentinel instantiation
+template <>
+class value_of<void> : public runtime_handle {
+	protected:
+		value_of() = default;
+		value_of(const runtime_lock& lock, runtime_handle value) :
+				runtime_handle{value},
+				lock_{&lock} {}
 
-		// Construct from any `value_handle`. Potentially unsafe.
-		static auto from(value_handle value_) -> value_of<Tag> { return std::bit_cast<value_of<Tag>>(value_); }
-};
+		[[nodiscard]] auto lock() const -> const runtime_lock& { return *lock_; }
 
-// Tagged isolated_vm value
-export template <class Tag>
-class value_of : public value_specialization<Tag>::value_type {
-	public:
-		using value_specialization<Tag>::value_type::value_type;
+	private:
+		const runtime_lock* lock_{};
 };
 
-template <std::derived_from<bound_value<void>> Type>
-value_of(Type) -> value_of<typename Type::tag_type>;
+// Deduction guide
+template <class Tag>
+value_of(auto, local_of<Tag>) -> value_of<Tag>;
 
-// Sentinel instantiation
-template <>
-class value_of<void> : public value_handle {
+// 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_handle::value_handle;
+		using tag_type = Tag;
+
+		value_next() = default;
+		value_next(auto&& lock, local_of<Tag> value, auto&&... rest) :
+				value_of<typename Tag::tag_type>{std::forward<decltype(lock)>(lock), value, std::forward<decltype(rest)>(rest)...} {}
+
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		operator local_of<Tag>() const { return local_of<Tag>::from(runtime_handle{*this}); }
 };
 
-} // namespace isolated_vm
+// `value_of<Tag>` specializations.
+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<isolated_vm::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<number_tag>
+		: std::type_identity<class value_for_number> {};
+
+template <>
+struct value_specialization<string_tag>
+		: std::type_identity<class value_for_string> {};
+
+template <>
+struct value_specialization<bigint_tag>
+		: std::type_identity<class value_for_bigint> {};
+
+template <>
+struct value_specialization<record_tag>
+		: std::type_identity<class value_for_record> {};
+
+template <>
+struct value_specialization<vector_tag>
+		: std::type_identity<class value_for_vector> {};
+
+template <>
+struct value_specialization<data_block_tag>
+		: std::type_identity<class value_for_data_block> {};
+
+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> {};
+
+} // namespace isolated_vm

package/addon/support/callback_info.cc

@@ -2,7 +2,7 @@ module;
 #include "auto_js/export_tag.h"
 #include <cassert>
 export module isolated_vm:support.callback_info_fwd;
-import :handle.value_of;
+import :handle.local_of;
 import :value.primitive;
 import auto_js;
 import std;
@@ -16,7 +16,7 @@ class EXPORT callback_info {
 
 	public:
 		class iterator;
-		using value_type = value_of<>;
+		using value_type = local_of<>;
 
 		[[nodiscard]] constexpr auto begin() const -> iterator;
 		[[nodiscard]] constexpr auto end() const -> iterator;
@@ -73,11 +73,11 @@ using namespace isolated_vm;
 
 // `arguments` visitor
 template <>
-struct visit_subject_for<callback_info> : visit_subject_for<value_of<>> {};
+struct visit_subject_for<callback_info> : visit_subject_for<local_of<>> {};
 
 template <class Meta>
-struct visit<Meta, callback_info> : visit<Meta, value_of<>> {
-		using visit_type = visit<Meta, value_of<>>;
+struct visit<Meta, callback_info> : visit<Meta, local_of<>> {
+		using visit_type = visit<Meta, local_of<>>;
 		using visit_type::visit_type;
 
 		using visit_type::operator();

package/addon/support/callback_storage.cc

@@ -10,7 +10,7 @@ import util;
 namespace isolated_vm {
 using namespace js;
 
-using runtime_callback_type = auto (*)(const runtime_lock&, callback_info, const void*) -> value_of<>;
+using runtime_callback_type = auto (*)(const runtime_lock&, callback_info, const void*) -> local_of<>;
 using runtime_callback_finalizer_type = auto (*)(void*) -> void;
 
 using runtime_callback_data_span_type = std::span<std::byte>;
@@ -42,7 +42,7 @@ const auto max_callback_storage_size = sizeof(runtime_callback_function_storage<
 auto make_callback_storage(std::invocable<const runtime_lock&, callback_info> auto function) {
 	using function_type = decltype(function);
 	using data_type = runtime_callback_function_storage<function_type>;
-	constexpr auto callback = runtime_callback_type{[](const runtime_lock& lock, callback_info info, const void* data) -> value_of<> {
+	constexpr auto callback = runtime_callback_type{[](const runtime_lock& lock, callback_info info, const void* data) -> local_of<> {
 		const auto& storage = *static_cast<const data_type*>(data);
 		return storage.function(lock, info);
 	}};

package/addon/support/free_function.cc

@@ -15,8 +15,8 @@ constexpr auto make_free_function(auto function) {
 		) -> auto {
 		using callback_type = decltype(callback);
 		auto bound_function = util::bind{
-			[](const callback_type& callback, Lock lock, callback_info info) noexcept(Nx) -> value_of<> {
-				auto run = util::regular_return{[ & ]() -> decltype(auto) {
+			[](const callback_type& callback, Lock lock, callback_info info) noexcept(Nx) -> local_of<> {
+				auto run = util::regular_return{[ & ] -> decltype(auto) {
 					return std::apply(
 						callback,
 						std::tuple_cat(
@@ -25,7 +25,7 @@ constexpr auto make_free_function(auto function) {
 						)
 					);
 				}};
-				return js::transfer_in_strict<value_of<>>(run().value_or(std::monostate{}), lock);
+				return js::transfer_in_strict<local_of<>>(run().value_or(std::monostate{}), lock);
 			},
 			std::move(callback),
 		};

package/addon/support/initialize.cc

@@ -9,7 +9,7 @@ import util;
 namespace isolated_vm {
 export namespace detail {
 using make_addon_names = auto() -> std::vector<std::u16string>;
-using accept_addon_values = auto(std::span<value_of<prototype_tag>>) -> void;
+using accept_addon_values = auto(std::span<local_of<prototype_tag>>) -> void;
 using initialize_addon = auto(const basic_lock&, util::function_ref<accept_addon_values>) -> void;
 } // namespace detail
 
@@ -30,7 +30,7 @@ template <std::size_t Index>
 consteval auto get_descriptors(std::integral_constant<std::size_t, Index> /*index*/, auto ns) {
 	return util::overloaded{
 		[]<class... Types>(std::tuple<std::in_place_t, Types...> ns) {
-			auto [... ii ] = util::sequence<sizeof...(Types)>;
+			constexpr auto [... ii ] = util::sequence<sizeof...(Types)>;
 			auto [... entries ] = std::make_tuple(std::get<ii + 1>(ns)...);
 			return std::make_tuple(std::get<Index>(entries)...);
 		},
@@ -46,10 +46,10 @@ addon::addon(std::type_identity<Type> /*environment*/, auto callback) {
 	using callback_type = decltype(callback);
 	static_assert(std::is_empty_v<callback_type>);
 
-	constexpr auto make_names = []() -> std::vector<std::u16string> {
+	constexpr auto make_names = [] -> std::vector<std::u16string> {
 		constexpr auto names = get_descriptors(std::integral_constant<std::size_t, 0>{}, callback_type{}());
 		// Check for duplicates (only at compile time)
-		static_assert([ names ]() {
+		static_assert([ names ] {
 			auto [... names_cw ] = names;
 			auto names_vector = std::vector{js::transfer_strict<std::u16string>(names_cw)...};
 			for (auto ii = names_vector.begin(); ii != names_vector.end(); ++ii) {
@@ -67,7 +67,7 @@ addon::addon(std::type_identity<Type> /*environment*/, auto callback) {
 	constexpr auto make_exports = [](const basic_lock& lock, util::function_ref<detail::accept_addon_values> make) -> void {
 		constexpr auto values = get_descriptors(std::integral_constant<std::size_t, 1>{}, callback_type{}());
 		constexpr auto size = std::tuple_size_v<decltype(values)>;
-		auto vm_values = js::transfer_in_strict<std::array<value_of<prototype_tag>, size>>(values, lock);
+		auto vm_values = js::transfer_in_strict<std::array<local_of<prototype_tag>, size>>(values, lock);
 		make(std::span{vm_values});
 	};
 	register_addon(make_names, make_exports);