nihil.ucl: improve type safety

7 files changed, 293 insertions, 88 deletions

diff --git a/nihil.ucl/CMakeLists.txt b/nihil.ucl/CMakeLists.txt
index f01fb25..9c6b3f3 100644
--- a/nihil.ucl/CMakeLists.txt
+++ b/nihil.ucl/CMakeLists.txt
@@ -10,7 +10,9 @@ target_sources(nihil.ucl PUBLIC
 	emit.ccm
 	error.ccm
 	object.ccm
+	object_cast.ccm
 	parser.ccm
+	type.ccm
 
 	array.ccm
 	boolean.ccm
diff --git a/nihil.ucl/array.ccm b/nihil.ucl/array.ccm
index 26cd9b9..7488bde 100644
--- a/nihil.ucl/array.ccm
+++ b/nihil.ucl/array.ccm
@@ -150,9 +150,7 @@ auto operator-(array_iterator<T> const &lhs,
 	return copy;
 }
 
-static_assert(std::random_access_iterator<array_iterator<object>>);
-
-export template<datatype T>
+export template<datatype T = object>
 struct array final : object {
 	inline static constexpr object_type ucl_type = object_type::array;
 
diff --git a/nihil.ucl/nihil.ucl.ccm b/nihil.ucl/nihil.ucl.ccm
index d0924d8..909fe18 100644
--- a/nihil.ucl/nihil.ucl.ccm
+++ b/nihil.ucl/nihil.ucl.ccm
@@ -5,9 +5,12 @@
 module;
 
 export module nihil.ucl;
+
 export import :emit;
 export import :object;
+export import :object_cast;
 export import :parser;
+export import :type;
 
 export import :array;
 export import :boolean;
diff --git a/nihil.ucl/object.ccm b/nihil.ucl/object.ccm
index 43f36fe..7286301 100644
--- a/nihil.ucl/object.ccm
+++ b/nihil.ucl/object.ccm
@@ -23,6 +23,7 @@ export module nihil.ucl:object;
 
 import nihil;
 import :error;
+import :type;
 
 namespace nihil::ucl {
 
@@ -32,26 +33,13 @@ export struct parser;
  * The basic object type.
  */
 
-enum struct object_type {
-	object = UCL_OBJECT,
-	array = UCL_ARRAY,
-	integer = UCL_INT,
-	real = UCL_FLOAT,
-	string = UCL_STRING,
-	boolean = UCL_BOOLEAN,
-	time = UCL_TIME,
-	userdata = UCL_USERDATA,
-	null = UCL_NULL,
-};
-
-template<typename T>
-concept datatype = requires(T o) {
-	{ T::ucl_type } -> std::convertible_to<object_type>;
-};
-
 export struct object {
 	inline static constexpr object_type ucl_type = object_type::object;
 
+	// Create an object from an existing ucl_object_t.  We assume the
+	// object has already been referenced.
+	object(::ucl_object_t *object) : _object(object) {}
+
 	// Free our object on destruction.
 	virtual ~object() {
 		if (_object)
@@ -100,28 +88,8 @@ export struct object {
 	// Return the type of this object.
 	auto type(this object const &self) -> object_type
 	{
-		switch (ucl_object_type(self.get_ucl_object())) {
-		case UCL_OBJECT:
-			return object_type::object;
-		case UCL_ARRAY:
-			return object_type::array;
-		case UCL_INT:
-			return object_type::integer;
-		case UCL_FLOAT:
-			return object_type::real;
-		case UCL_STRING:
-			return object_type::string;
-		case UCL_BOOLEAN:
-			return object_type::boolean;
-		case UCL_TIME:
-			return object_type::time;
-		case UCL_USERDATA:
-			return object_type::userdata;
-		case UCL_NULL:
-			return object_type::null;
-		default:
-			std::abort();
-		}
+		auto utype = ::ucl_object_type(self.get_ucl_object());
+		return static_cast<object_type>(utype);
 	}
 
 	// Return the underlying object.
@@ -156,10 +124,6 @@ export struct object {
 	}
 
 protected:
-	// Create an object from an existing ucl_object_t.  We assume the
-	// object has already been referenced.
-	object(::ucl_object_t *object) : _object(object) {}
-
 	// The object we're wrapping.
 	::ucl_object_t *_object = nullptr;
 
@@ -274,29 +238,4 @@ export auto end(object const &) -> iterator::sentinel
 	return {};
 }
 
-/***********************************************************************
- * Value access by object_cast.
- */
-
-// Exception thrown when object_cast fails.
-export struct bad_object_cast : error {
-	bad_object_cast()
-		: error("bad object_cast<>: object does not match target type")
-	{}
-};
-
-//export template<typename To>
-////auto object_cast(object const &from) -> To = delete;
-
-export template<datatype To>
-auto object_cast(object const &from) -> To
-{
-	if (from.type() != To::ucl_type)
-		throw bad_object_cast();
-
-	auto const *uobj = from.get_ucl_object();
-	auto *refptr = ::ucl_object_ref(uobj);
-	return To(refptr);
-}
-
 } // namespace nihil::ucl
diff --git a/nihil.ucl/object_cast.ccm b/nihil.ucl/object_cast.ccm
new file mode 100644
index 0000000..7291960
--- /dev/null
+++ b/nihil.ucl/object_cast.ccm
@@ -0,0 +1,81 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+module;
+
+#include <cstdlib>
+
+#include <ucl.h>
+
+export module nihil.ucl:object_cast;
+
+import :type;
+import :object;
+import :array;
+
+namespace nihil::ucl {
+
+/*
+ * Ensure a UCL object is convertible to another type.  Throws type_mismatch
+ * if not.
+ */
+
+// Implementation for basic types.
+template<datatype To>
+struct convert_check
+{
+	auto check(::ucl_object_t const *from) -> void
+	{
+		auto from_type = static_cast<object_type>(::ucl_object_type(from));
+		auto to_type = To::ucl_type;
+
+		// Converting from anything to object is permitted.
+		if (to_type == object_type::object)
+			return;
+
+		// Converting between two equal types is permitted.
+		if (from_type == to_type)
+			return;
+
+		// Otherwise, this is an error.
+		throw type_mismatch(to_type, from_type);
+	}
+};
+
+// Implementation for array.
+template<typename T>
+struct convert_check<array<T>>
+{
+	auto check(::ucl_object_t const *from) -> void
+	{
+		using To = array<T>;
+		auto from_type = static_cast<object_type>(::ucl_object_type(from));
+		auto to_type = To::ucl_type;
+
+		// If the source type is not an array, this is an error.
+		if (from_type != object_type::array)
+			throw type_mismatch(to_type, from_type);
+
+		for (std::size_t i = 0, size = ::ucl_array_size(from);
+		     i < size; ++i) {
+			auto const *arr_obj = ::ucl_array_find_index(from, i);
+			convert_check<typename To::value_type>{}.check(arr_obj);
+		}
+	}
+};
+
+/*
+ * Convert a UCL object to another type.
+ */
+export template<datatype To>
+auto object_cast(object const &from) -> To
+{
+	convert_check<To>{}.check(from.get_ucl_object());
+
+	auto const *uobj = from.get_ucl_object();
+	auto *refptr = ::ucl_object_ref(uobj);
+	return To(refptr);
+}
+
+} // namespace nihil::ucl
diff --git a/nihil.ucl/tests/array.cc b/nihil.ucl/tests/array.cc
index 60cb61d..220564d 100644
--- a/nihil.ucl/tests/array.cc
+++ b/nihil.ucl/tests/array.cc
@@ -12,18 +12,23 @@ import nihil.ucl;
 
 TEST_CASE("ucl: array: construct", "[ucl]")
 {
-	auto arr = nihil::ucl::array<nihil::ucl::integer>();
+	using namespace nihil::ucl;
+
+	auto arr = array<integer>();
 	REQUIRE(arr.size() == 0);
+	REQUIRE(str(arr.type()) == "array");
 }
 
 TEST_CASE("ucl: array: push_back", "[ucl]")
 {
-	auto arr = nihil::ucl::array<nihil::ucl::integer>();
+	using namespace nihil::ucl;
+
+	auto arr = array<integer>();
 	REQUIRE(arr.size() == 0);
 
-	arr.push_back(nihil::ucl::integer(1));
-	arr.push_back(nihil::ucl::integer(42));
-	arr.push_back(nihil::ucl::integer(666));
+	arr.push_back(integer(1));
+	arr.push_back(integer(42));
+	arr.push_back(integer(666));
 
 	REQUIRE(arr.size() == 3);
 	REQUIRE(arr[0].value() == 1);
@@ -34,17 +39,18 @@ TEST_CASE("ucl: array: push_back", "[ucl]")
 
 	REQUIRE(arr.front() == 1);
 	REQUIRE(arr.back() == 666);
-
 }
 
 TEST_CASE("ucl: array: compare", "[ucl]")
 {
-	auto arr = nihil::ucl::array<nihil::ucl::integer>();
+	using namespace nihil::ucl;
+
+	auto arr = array<integer>();
 	arr.push_back(1);
 	arr.push_back(42);
 	arr.push_back(666);
 
-	auto arr2 = nihil::ucl::array<nihil::ucl::integer>();
+	auto arr2 = array<integer>();
 	REQUIRE(arr != arr2);
 
 	arr2.push_back(1);
@@ -52,7 +58,7 @@ TEST_CASE("ucl: array: compare", "[ucl]")
 	arr2.push_back(666);
 	REQUIRE(arr == arr2);
 
-	auto arr3 = nihil::ucl::array<nihil::ucl::integer>();
+	auto arr3 = array<integer>();
 	arr3.push_back(1);
 	arr3.push_back(1);
 	arr3.push_back(1);
@@ -61,10 +67,15 @@ TEST_CASE("ucl: array: compare", "[ucl]")
 
 TEST_CASE("ucl: array: iterator", "[ucl]")
 {
-	auto arr = nihil::ucl::array<nihil::ucl::integer>{1, 42, 666};
+	using namespace nihil::ucl;
+
+	auto arr = array<integer>{1, 42, 666};
 
 	auto it = arr.begin();
 	REQUIRE(*it == 1);
+	auto end = arr.end();
+	REQUIRE(it != end);
+	REQUIRE(it < end);
 
 	++it;
 	REQUIRE(*it == 42);
@@ -74,20 +85,26 @@ TEST_CASE("ucl: array: iterator", "[ucl]")
 
 	--it;
 	REQUIRE(*it == 42);
+
+	++it;
+	REQUIRE(it != end);
+	++it;
+	REQUIRE(it == end);
 }
 
 TEST_CASE("ucl: array: parse", "[ucl]")
 {
 	using namespace std::literals;
+	using namespace nihil::ucl;
 
 	auto input = "value = [1, 42, 666]"sv;
-	auto obj = nihil::ucl::parse(input);
+	auto obj = parse(input);
 	auto v = obj.lookup("value");
 
 	REQUIRE(v);
 	REQUIRE(v->key() == "value");
 
-	auto arr = object_cast<nihil::ucl::array<nihil::ucl::integer>>(*v);
+	auto arr = object_cast<array<integer>>(*v);
 	REQUIRE(arr.size() == 3);
 	REQUIRE(arr[0] == 1);
 	REQUIRE(arr[1] == 42);
@@ -96,7 +113,9 @@ TEST_CASE("ucl: array: parse", "[ucl]")
 
 TEST_CASE("ucl: array: emit", "[ucl]")
 {
-	auto ucl = nihil::ucl::parse("array = [1, 42, 666];");
+	using namespace nihil::ucl;
+
+	auto ucl = parse("array = [1, 42, 666];");
 	auto output = std::format("{:c}", ucl);
 	REQUIRE(output == 
 "array [\n"
@@ -108,7 +127,9 @@ TEST_CASE("ucl: array: emit", "[ucl]")
 
 TEST_CASE("ucl: array is a sized_range", "[ucl]")
 {
-	auto arr = nihil::ucl::array<nihil::ucl::integer>{1, 42, 666};
+	using namespace nihil::ucl;
+
+	auto arr = array<integer>{1, 42, 666};
 	static_assert(std::ranges::sized_range<decltype(arr)>);
 
 	auto size = std::ranges::size(arr);
@@ -116,19 +137,87 @@ TEST_CASE("ucl: array is a sized_range", "[ucl]")
 
 	auto begin = std::ranges::begin(arr);
 	static_assert(std::random_access_iterator<decltype(begin)>);
+
 	auto end = std::ranges::end(arr);
 	static_assert(std::sentinel_for<decltype(end), decltype(begin)>);
 
 	REQUIRE(std::distance(begin, end) == 3);
 
-	auto vec = std::vector<nihil::ucl::integer>();
+	auto vec = std::vector<integer>();
 	std::ranges::copy(arr, std::back_inserter(vec));
 	REQUIRE(std::ranges::equal(arr, vec));
 
 	auto arr_as_ints =
-		arr | std::views::transform(&nihil::ucl::integer::value);
-	auto int_vec = std::vector<nihil::ucl::integer::value_type>();
+		arr | std::views::transform(&integer::value);
+	auto int_vec = std::vector<integer::value_type>();
 	std::ranges::copy(arr_as_ints, std::back_inserter(int_vec));
 	REQUIRE(int_vec == std::vector<std::int64_t>{1, 42, 666});
 
 }
+
+TEST_CASE("ucl: array: bad object_cast", "[ucl]")
+{
+	using namespace nihil::ucl;
+
+	auto arr = array<integer>();
+
+	REQUIRE_THROWS_AS(object_cast<integer>(arr), type_mismatch);
+}
+
+TEST_CASE("ucl: array: heterogeneous elements", "[ucl]")
+{
+	using namespace std::literals;
+	using namespace nihil::ucl;
+
+	auto obj = parse("array [ 42, true, \"test\" ];");
+	auto v = obj.lookup("array");
+	REQUIRE(v);
+	auto arr = object_cast<array<>>(*v);
+
+	REQUIRE(arr.size() == 3);
+
+	auto int_obj = object_cast<integer>(arr[0]);
+	REQUIRE(int_obj == 42);
+
+	auto bool_obj = object_cast<boolean>(arr[1]);
+	REQUIRE(bool_obj == true);
+
+	auto string_obj = object_cast<string>(arr[2]);
+	REQUIRE(string_obj == "test");
+}
+
+TEST_CASE("ucl: array: heterogenous cast", "[ucl]")
+{
+	using namespace nihil::ucl;
+
+	auto arr = array<>();
+	arr.push_back(integer(42));
+	arr.push_back(boolean(true));
+
+	// Converting to an array<integer> should fail.
+	REQUIRE_THROWS_AS(object_cast<array<integer>>(arr), type_mismatch);
+
+	// Converting to array<object> should succeed.
+	auto obj_arr = object_cast<array<object>>(arr);
+	REQUIRE(obj_arr[0] == integer(42));
+}
+
+TEST_CASE("ucl: array: homogeneous cast", "[ucl]")
+{
+	using namespace nihil::ucl;
+
+	auto arr = array<>();
+	arr.push_back(integer(1));
+	arr.push_back(integer(42));
+
+	auto obj = object(arr.get_ucl_object());
+
+	// Converting to array<string> should fail.
+	REQUIRE_THROWS_AS(object_cast<array<string>>(obj), type_mismatch);
+
+	// Converting to an array<integer> should succeed.
+	auto obj_arr = object_cast<array<integer>>(obj);
+	REQUIRE(obj_arr[0] == 1);
+	REQUIRE(obj_arr[1] == 42);
+}
+
diff --git a/nihil.ucl/type.ccm b/nihil.ucl/type.ccm
new file mode 100644
index 0000000..2aef1a6
--- /dev/null
+++ b/nihil.ucl/type.ccm
@@ -0,0 +1,93 @@
+/*
+ * This source code is released into the public domain.
+ */
+
+module;
+
+#include <concepts>
+#include <string>
+
+#include <ucl.h>
+
+export module nihil.ucl:type;
+
+import :error;
+
+namespace nihil::ucl {
+
+// Our strongly-typed version of ::ucl_type.
+export enum struct object_type {
+	object		= UCL_OBJECT,
+	array		= UCL_ARRAY,
+	integer		= UCL_INT,
+	real		= UCL_FLOAT,
+	string		= UCL_STRING,
+	boolean		= UCL_BOOLEAN,
+	time		= UCL_TIME,
+	userdata	= UCL_USERDATA,
+	null		= UCL_NULL,
+};
+
+// Get the name of a type.
+export auto str(object_type type) -> std::string_view {
+	using namespace std::literals;
+
+	switch (type) {
+	case object_type::object:
+		return "object"sv;
+	case object_type::array:
+		return "array"sv;
+	case object_type::integer:
+		return "integer"sv;
+	case object_type::real:
+		return "real"sv;
+	case object_type::string:
+		return "string"sv;
+	case object_type::boolean:
+		return "boolean"sv;
+	case object_type::time:
+		return "time"sv;
+	case object_type::userdata:
+		return "userdata"sv;
+	case object_type::null:
+		return "null"sv;
+	default:
+		// Don't fail here, since UCL might add more types that we
+		// don't know about.
+		return "unknown"sv;
+	}
+}
+
+// Concept of a UCL data type.
+export template<typename T>
+concept datatype = requires(T o) {
+	{ o.get_ucl_object() } -> std::convertible_to<::ucl_object_t const *>;
+	{ o.type() } -> std::same_as<object_type>;
+	{ T::ucl_type } -> std::convertible_to<object_type>;
+};
+
+// Exception thrown when a type assertion fails.
+export struct type_mismatch : error {
+	type_mismatch(object_type expected_type, object_type actual_type)
+		: error("UCL type mismatch: expected type '{}' != actual type '{}'",
+			str(expected_type), str(actual_type))
+		, _expected_type(expected_type)
+		, _actual_type(actual_type)
+	{}
+
+	// The type we expected.
+	auto expected_type(this type_mismatch const &self) -> object_type {
+		return self._expected_type;
+	}
+
+	// The type we got.
+	auto actual_type(this type_mismatch const &self) -> object_type {
+		return self._actual_type;
+	}
+	
+private:
+	object_type _expected_type;
+	object_type _actual_type;
+};
+
+} // namespace nihil::ucl