Simplify ast_node by inheriting parse_tree::basic_node

Author: wravery

include/graphqlservice/internal/SyntaxTree.h

@@ -11,6 +11,7 @@
 #define TAO_PEGTL_NAMESPACE tao::graphqlpeg
 
 #include <tao/pegtl.hpp>
+#include <tao/pegtl/contrib/parse_tree.hpp>
 
 #include <string>
 #include <string_view>
@@ -22,27 +23,9 @@ namespace graphql::peg {
 using namespace tao::graphqlpeg;
 namespace peginternal = tao::graphqlpeg::internal;
 
-class [[nodiscard]] ast_node
+class [[nodiscard]] ast_node : public parse_tree::basic_node<ast_node>
 {
 public:
-	// Must be default constructible
-	ast_node() = default;
-
-	// Nodes are always owned/handled by a std::unique_ptr
-	// and never copied or assigned...
-	ast_node(const ast_node&) = delete;
-	ast_node(ast_node&&) = delete;
-	ast_node& operator=(const ast_node&) = delete;
-	ast_node& operator=(ast_node&&) = delete;
-
-	// Must be destructible
-	~ast_node() = default;
-
-	[[nodiscard]] GRAPHQLPEG_EXPORT bool is_root() const noexcept;
-	[[nodiscard]] GRAPHQLPEG_EXPORT position begin() const noexcept;
-	[[nodiscard]] GRAPHQLPEG_EXPORT std::string_view string_view() const noexcept;
-	[[nodiscard]] GRAPHQLPEG_EXPORT std::string string() const noexcept;
-	[[nodiscard]] GRAPHQLPEG_EXPORT bool has_content() const noexcept;
 	GRAPHQLPEG_EXPORT void remove_content() noexcept;
 
 	GRAPHQLPEG_EXPORT void unescaped_view(std::string_view unescaped) noexcept;
@@ -55,31 +38,21 @@ class [[nodiscard]] ast_node
 
 		// The pointer comparison doesn't work with shared libraries where the parse tree is
 		// constructed in one module and consumed in another. So to optimize this comparison, check
-		// the size first, then the hash (cached in a static local variable per specialization of
-		// type_hash<U>()), then the pointer comparison with a full string compare as fallback.
-		return _type.size() == u.size() && _type_hash == type_hash<U>()
-			&& (_type.data() == u.data() || _type == u);
+		// the size first, then the pointer (cached in a static local variable per specialization of
+		// type_name<U>()), then the hash (cached in a static local variable per specialization of
+		// type_hash<U>()) and a full string compare as fallback.
+		return _type_name.size() == u.size()
+			&& (_type_name.data() == u.data() || (_type_hash == type_hash<U>() && _type_name == u));
 	}
 
-	// All non-root nodes receive a call to start() when
-	// a match is attempted for Rule in a parsing run...
-	template <typename ParseInput>
-	void start(const ParseInput& in)
-	{
-		_begin = in.iterator();
-	}
+	using basic_node_t = parse_tree::basic_node<ast_node>;
 
-	// ...and later a call to success() when the match succeeded...
 	template <typename Rule, typename ParseInput>
 	void success(const ParseInput& in)
 	{
-		const char* end = in.iterator().data;
-
-		_type = type_name<Rule>();
+		basic_node_t::template success<Rule>(in);
+		_type_name = type_name<Rule>();
 		_type_hash = type_hash<Rule>();
-		_source = in.source();
-		_content = { _begin.data, static_cast<size_t>(end - _begin.data) };
-		_unescaped.reset();
 	}
 
 	using children_t = std::vector<std::unique_ptr<ast_node>>;
@@ -91,7 +64,9 @@ class [[nodiscard]] ast_node
 	[[nodiscard]] static std::string_view type_name() noexcept
 	{
 		// This is cached in a static local variable per-specialization, but each module may have
-		// its own instance of the specialization and the local variable.
+		// its own instance of the specialization and the local variable. Within a single module,
+		// the pointer returned from std::string_view::data() should always be equal, which speeds
+		// up the string comparison in is_type.
 		static const std::string_view name { tao::graphqlpeg::demangle<U>() };
 
 		return name;
@@ -102,20 +77,17 @@ class [[nodiscard]] ast_node
 	{
 		// This is cached in a static local variable per-specialization, but each module may have
 		// its own instance of the specialization and the local variable.
-		static const size_t hash = std::hash<std::string_view>()(type_name<U>());
+		static const size_t hash = std::hash<std::string_view> {}(type_name<U>());
 
 		return hash;
 	}
 
-	std::string_view _source;
-	peginternal::iterator _begin;
-	std::string_view _type;
+	std::string_view _type_name;
 	size_t _type_hash = 0;
-	std::string_view _content;
 
 	using unescaped_t = std::variant<std::string_view, std::string>;
 
-	std::unique_ptr<unescaped_t> _unescaped;
+	mutable std::unique_ptr<unescaped_t> _unescaped;
 };
 
 template <class ParseInput>

src/SyntaxTree.cpp

@@ -6,7 +6,6 @@
 #include "graphqlservice/internal/Grammar.h"
 #include "graphqlservice/internal/SyntaxTree.h"
 
-#include <tao/pegtl/contrib/parse_tree.hpp>
 #include <tao/pegtl/contrib/unescape.hpp>
 
 #include <functional>
@@ -22,26 +21,6 @@ using namespace std::literals;
 namespace graphql {
 namespace peg {
 
-bool ast_node::is_root() const noexcept
-{
-	return _type.empty();
-}
-
-position ast_node::begin() const noexcept
-{
-	return { _begin, _source };
-}
-
-std::string_view ast_node::string_view() const noexcept
-{
-	return _content;
-}
-
-std::string ast_node::string() const noexcept
-{
-	return std::string { string_view() };
-}
-
 void ast_node::unescaped_view(std::string_view unescaped) noexcept
 {
 	_unescaped = std::make_unique<unescaped_t>(unescaped);
@@ -131,8 +110,7 @@ std::string_view ast_node::unescaped_view() const
 				}
 			}
 
-			const_cast<ast_node*>(this)->_unescaped =
-				std::make_unique<unescaped_t>(std::move(joined));
+			_unescaped = std::make_unique<unescaped_t>(std::move(joined));
 		}
 		else if (children.size() > 1)
 		{
@@ -150,13 +128,11 @@ std::string_view ast_node::unescaped_view() const
 				joined.append(child->string_view());
 			}
 
-			const_cast<ast_node*>(this)->_unescaped =
-				std::make_unique<unescaped_t>(std::move(joined));
+			_unescaped = std::make_unique<unescaped_t>(std::move(joined));
 		}
 		else if (!children.empty())
 		{
-			const_cast<ast_node*>(this)->_unescaped =
-				std::make_unique<unescaped_t>(children.front()->string_view());
+			_unescaped = std::make_unique<unescaped_t>(children.front()->string_view());
 		}
 		else if (has_content() && is_type<escaped_unicode>())
 		{
@@ -167,13 +143,11 @@ std::string_view ast_node::unescaped_view() const
 			utf8.reserve((content.size() + 1) / 2);
 			unescape::unescape_j::apply(in, utf8);
 
-			const_cast<ast_node*>(this)->_unescaped =
-				std::make_unique<unescaped_t>(std::move(utf8));
+			_unescaped = std::make_unique<unescaped_t>(std::move(utf8));
 		}
 		else
 		{
-			const_cast<ast_node*>(this)->_unescaped =
-				std::make_unique<unescaped_t>(std::string_view {});
+			_unescaped = std::make_unique<unescaped_t>(std::string_view {});
 		}
 	}
 
@@ -184,14 +158,9 @@ std::string_view ast_node::unescaped_view() const
 		*_unescaped);
 }
 
-bool ast_node::has_content() const noexcept
-{
-	return !string_view().empty();
-}
-
 void ast_node::remove_content() noexcept
 {
-	_content = {};
+	basic_node_t::remove_content();
 	_unescaped.reset();
 }
 
@@ -960,7 +929,7 @@ struct make_control<Selector>::state_handler<Rule, true, B> : ast_control<Rule>
 	static void start(const ParseInput& in, ast_state& state)
 	{
 		state.emplace_back();
-		state.back()->start(in);
+		state.back()->template start<Rule>(in);
 	}
 
 	template <typename ParseInput>