prism 2.0.0.rc1-x86_64-linux-gnu → 2.0.0-x86_64-linux-gnu

data/include/prism/ast.hpp

@@ -0,0 +1,641 @@
+/*----------------------------------------------------------------------------*/
+/* This file is generated by the templates/template.rb script and should not  */
+/* be modified manually. See                                                  */
+/* templates/include/prism/ast.hpp.erb                                        */
+/* if you are looking to modify the                                           */
+/* template                                                                   */
+/*----------------------------------------------------------------------------*/
+
+/**
+ * @file ast.hpp
+ *
+ * The mapping between node structs and node types, generated from the same
+ * configuration as ast.h so that it covers every node.
+ */
+#ifndef PRISM_AST_HPP
+#define PRISM_AST_HPP
+
+#include "prism/compiler/cplusplus.hpp"
+
+#include "prism/ast.h"
+#include "prism/node_type.hpp"
+
+#include <cstddef>
+#include <type_traits>
+
+namespace prism {
+
+/* Each node struct is cast to and from pm_node_t, which C++ allows only
+ * because the struct is standard-layout with pm_node_t as its first member. */
+
+/** Maps pm_alias_global_variable_node_t to PM_ALIAS_GLOBAL_VARIABLE_NODE. */
+template <> struct node_type<pm_alias_global_variable_node_t> : std::integral_constant<pm_node_type_t, PM_ALIAS_GLOBAL_VARIABLE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_alias_global_variable_node_t> && offsetof(pm_alias_global_variable_node_t, base) == 0, "pm_alias_global_variable_node_t must begin with its pm_node_t");
+
+/** Maps pm_alias_method_node_t to PM_ALIAS_METHOD_NODE. */
+template <> struct node_type<pm_alias_method_node_t> : std::integral_constant<pm_node_type_t, PM_ALIAS_METHOD_NODE> {};
+static_assert(std::is_standard_layout_v<pm_alias_method_node_t> && offsetof(pm_alias_method_node_t, base) == 0, "pm_alias_method_node_t must begin with its pm_node_t");
+
+/** Maps pm_alternation_pattern_node_t to PM_ALTERNATION_PATTERN_NODE. */
+template <> struct node_type<pm_alternation_pattern_node_t> : std::integral_constant<pm_node_type_t, PM_ALTERNATION_PATTERN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_alternation_pattern_node_t> && offsetof(pm_alternation_pattern_node_t, base) == 0, "pm_alternation_pattern_node_t must begin with its pm_node_t");
+
+/** Maps pm_and_node_t to PM_AND_NODE. */
+template <> struct node_type<pm_and_node_t> : std::integral_constant<pm_node_type_t, PM_AND_NODE> {};
+static_assert(std::is_standard_layout_v<pm_and_node_t> && offsetof(pm_and_node_t, base) == 0, "pm_and_node_t must begin with its pm_node_t");
+
+/** Maps pm_arguments_node_t to PM_ARGUMENTS_NODE. */
+template <> struct node_type<pm_arguments_node_t> : std::integral_constant<pm_node_type_t, PM_ARGUMENTS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_arguments_node_t> && offsetof(pm_arguments_node_t, base) == 0, "pm_arguments_node_t must begin with its pm_node_t");
+
+/** Maps pm_array_node_t to PM_ARRAY_NODE. */
+template <> struct node_type<pm_array_node_t> : std::integral_constant<pm_node_type_t, PM_ARRAY_NODE> {};
+static_assert(std::is_standard_layout_v<pm_array_node_t> && offsetof(pm_array_node_t, base) == 0, "pm_array_node_t must begin with its pm_node_t");
+
+/** Maps pm_array_pattern_node_t to PM_ARRAY_PATTERN_NODE. */
+template <> struct node_type<pm_array_pattern_node_t> : std::integral_constant<pm_node_type_t, PM_ARRAY_PATTERN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_array_pattern_node_t> && offsetof(pm_array_pattern_node_t, base) == 0, "pm_array_pattern_node_t must begin with its pm_node_t");
+
+/** Maps pm_assoc_node_t to PM_ASSOC_NODE. */
+template <> struct node_type<pm_assoc_node_t> : std::integral_constant<pm_node_type_t, PM_ASSOC_NODE> {};
+static_assert(std::is_standard_layout_v<pm_assoc_node_t> && offsetof(pm_assoc_node_t, base) == 0, "pm_assoc_node_t must begin with its pm_node_t");
+
+/** Maps pm_assoc_splat_node_t to PM_ASSOC_SPLAT_NODE. */
+template <> struct node_type<pm_assoc_splat_node_t> : std::integral_constant<pm_node_type_t, PM_ASSOC_SPLAT_NODE> {};
+static_assert(std::is_standard_layout_v<pm_assoc_splat_node_t> && offsetof(pm_assoc_splat_node_t, base) == 0, "pm_assoc_splat_node_t must begin with its pm_node_t");
+
+/** Maps pm_back_reference_read_node_t to PM_BACK_REFERENCE_READ_NODE. */
+template <> struct node_type<pm_back_reference_read_node_t> : std::integral_constant<pm_node_type_t, PM_BACK_REFERENCE_READ_NODE> {};
+static_assert(std::is_standard_layout_v<pm_back_reference_read_node_t> && offsetof(pm_back_reference_read_node_t, base) == 0, "pm_back_reference_read_node_t must begin with its pm_node_t");
+
+/** Maps pm_begin_node_t to PM_BEGIN_NODE. */
+template <> struct node_type<pm_begin_node_t> : std::integral_constant<pm_node_type_t, PM_BEGIN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_begin_node_t> && offsetof(pm_begin_node_t, base) == 0, "pm_begin_node_t must begin with its pm_node_t");
+
+/** Maps pm_block_argument_node_t to PM_BLOCK_ARGUMENT_NODE. */
+template <> struct node_type<pm_block_argument_node_t> : std::integral_constant<pm_node_type_t, PM_BLOCK_ARGUMENT_NODE> {};
+static_assert(std::is_standard_layout_v<pm_block_argument_node_t> && offsetof(pm_block_argument_node_t, base) == 0, "pm_block_argument_node_t must begin with its pm_node_t");
+
+/** Maps pm_block_local_variable_node_t to PM_BLOCK_LOCAL_VARIABLE_NODE. */
+template <> struct node_type<pm_block_local_variable_node_t> : std::integral_constant<pm_node_type_t, PM_BLOCK_LOCAL_VARIABLE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_block_local_variable_node_t> && offsetof(pm_block_local_variable_node_t, base) == 0, "pm_block_local_variable_node_t must begin with its pm_node_t");
+
+/** Maps pm_block_node_t to PM_BLOCK_NODE. */
+template <> struct node_type<pm_block_node_t> : std::integral_constant<pm_node_type_t, PM_BLOCK_NODE> {};
+static_assert(std::is_standard_layout_v<pm_block_node_t> && offsetof(pm_block_node_t, base) == 0, "pm_block_node_t must begin with its pm_node_t");
+
+/** Maps pm_block_parameter_node_t to PM_BLOCK_PARAMETER_NODE. */
+template <> struct node_type<pm_block_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_BLOCK_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_block_parameter_node_t> && offsetof(pm_block_parameter_node_t, base) == 0, "pm_block_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_block_parameters_node_t to PM_BLOCK_PARAMETERS_NODE. */
+template <> struct node_type<pm_block_parameters_node_t> : std::integral_constant<pm_node_type_t, PM_BLOCK_PARAMETERS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_block_parameters_node_t> && offsetof(pm_block_parameters_node_t, base) == 0, "pm_block_parameters_node_t must begin with its pm_node_t");
+
+/** Maps pm_break_node_t to PM_BREAK_NODE. */
+template <> struct node_type<pm_break_node_t> : std::integral_constant<pm_node_type_t, PM_BREAK_NODE> {};
+static_assert(std::is_standard_layout_v<pm_break_node_t> && offsetof(pm_break_node_t, base) == 0, "pm_break_node_t must begin with its pm_node_t");
+
+/** Maps pm_call_and_write_node_t to PM_CALL_AND_WRITE_NODE. */
+template <> struct node_type<pm_call_and_write_node_t> : std::integral_constant<pm_node_type_t, PM_CALL_AND_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_call_and_write_node_t> && offsetof(pm_call_and_write_node_t, base) == 0, "pm_call_and_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_call_node_t to PM_CALL_NODE. */
+template <> struct node_type<pm_call_node_t> : std::integral_constant<pm_node_type_t, PM_CALL_NODE> {};
+static_assert(std::is_standard_layout_v<pm_call_node_t> && offsetof(pm_call_node_t, base) == 0, "pm_call_node_t must begin with its pm_node_t");
+
+/** Maps pm_call_operator_write_node_t to PM_CALL_OPERATOR_WRITE_NODE. */
+template <> struct node_type<pm_call_operator_write_node_t> : std::integral_constant<pm_node_type_t, PM_CALL_OPERATOR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_call_operator_write_node_t> && offsetof(pm_call_operator_write_node_t, base) == 0, "pm_call_operator_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_call_or_write_node_t to PM_CALL_OR_WRITE_NODE. */
+template <> struct node_type<pm_call_or_write_node_t> : std::integral_constant<pm_node_type_t, PM_CALL_OR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_call_or_write_node_t> && offsetof(pm_call_or_write_node_t, base) == 0, "pm_call_or_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_call_target_node_t to PM_CALL_TARGET_NODE. */
+template <> struct node_type<pm_call_target_node_t> : std::integral_constant<pm_node_type_t, PM_CALL_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_call_target_node_t> && offsetof(pm_call_target_node_t, base) == 0, "pm_call_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_capture_pattern_node_t to PM_CAPTURE_PATTERN_NODE. */
+template <> struct node_type<pm_capture_pattern_node_t> : std::integral_constant<pm_node_type_t, PM_CAPTURE_PATTERN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_capture_pattern_node_t> && offsetof(pm_capture_pattern_node_t, base) == 0, "pm_capture_pattern_node_t must begin with its pm_node_t");
+
+/** Maps pm_case_match_node_t to PM_CASE_MATCH_NODE. */
+template <> struct node_type<pm_case_match_node_t> : std::integral_constant<pm_node_type_t, PM_CASE_MATCH_NODE> {};
+static_assert(std::is_standard_layout_v<pm_case_match_node_t> && offsetof(pm_case_match_node_t, base) == 0, "pm_case_match_node_t must begin with its pm_node_t");
+
+/** Maps pm_case_node_t to PM_CASE_NODE. */
+template <> struct node_type<pm_case_node_t> : std::integral_constant<pm_node_type_t, PM_CASE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_case_node_t> && offsetof(pm_case_node_t, base) == 0, "pm_case_node_t must begin with its pm_node_t");
+
+/** Maps pm_class_node_t to PM_CLASS_NODE. */
+template <> struct node_type<pm_class_node_t> : std::integral_constant<pm_node_type_t, PM_CLASS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_class_node_t> && offsetof(pm_class_node_t, base) == 0, "pm_class_node_t must begin with its pm_node_t");
+
+/** Maps pm_class_variable_and_write_node_t to PM_CLASS_VARIABLE_AND_WRITE_NODE. */
+template <> struct node_type<pm_class_variable_and_write_node_t> : std::integral_constant<pm_node_type_t, PM_CLASS_VARIABLE_AND_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_class_variable_and_write_node_t> && offsetof(pm_class_variable_and_write_node_t, base) == 0, "pm_class_variable_and_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_class_variable_operator_write_node_t to PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE. */
+template <> struct node_type<pm_class_variable_operator_write_node_t> : std::integral_constant<pm_node_type_t, PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_class_variable_operator_write_node_t> && offsetof(pm_class_variable_operator_write_node_t, base) == 0, "pm_class_variable_operator_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_class_variable_or_write_node_t to PM_CLASS_VARIABLE_OR_WRITE_NODE. */
+template <> struct node_type<pm_class_variable_or_write_node_t> : std::integral_constant<pm_node_type_t, PM_CLASS_VARIABLE_OR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_class_variable_or_write_node_t> && offsetof(pm_class_variable_or_write_node_t, base) == 0, "pm_class_variable_or_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_class_variable_read_node_t to PM_CLASS_VARIABLE_READ_NODE. */
+template <> struct node_type<pm_class_variable_read_node_t> : std::integral_constant<pm_node_type_t, PM_CLASS_VARIABLE_READ_NODE> {};
+static_assert(std::is_standard_layout_v<pm_class_variable_read_node_t> && offsetof(pm_class_variable_read_node_t, base) == 0, "pm_class_variable_read_node_t must begin with its pm_node_t");
+
+/** Maps pm_class_variable_target_node_t to PM_CLASS_VARIABLE_TARGET_NODE. */
+template <> struct node_type<pm_class_variable_target_node_t> : std::integral_constant<pm_node_type_t, PM_CLASS_VARIABLE_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_class_variable_target_node_t> && offsetof(pm_class_variable_target_node_t, base) == 0, "pm_class_variable_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_class_variable_write_node_t to PM_CLASS_VARIABLE_WRITE_NODE. */
+template <> struct node_type<pm_class_variable_write_node_t> : std::integral_constant<pm_node_type_t, PM_CLASS_VARIABLE_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_class_variable_write_node_t> && offsetof(pm_class_variable_write_node_t, base) == 0, "pm_class_variable_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_and_write_node_t to PM_CONSTANT_AND_WRITE_NODE. */
+template <> struct node_type<pm_constant_and_write_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_AND_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_and_write_node_t> && offsetof(pm_constant_and_write_node_t, base) == 0, "pm_constant_and_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_operator_write_node_t to PM_CONSTANT_OPERATOR_WRITE_NODE. */
+template <> struct node_type<pm_constant_operator_write_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_OPERATOR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_operator_write_node_t> && offsetof(pm_constant_operator_write_node_t, base) == 0, "pm_constant_operator_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_or_write_node_t to PM_CONSTANT_OR_WRITE_NODE. */
+template <> struct node_type<pm_constant_or_write_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_OR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_or_write_node_t> && offsetof(pm_constant_or_write_node_t, base) == 0, "pm_constant_or_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_path_and_write_node_t to PM_CONSTANT_PATH_AND_WRITE_NODE. */
+template <> struct node_type<pm_constant_path_and_write_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_PATH_AND_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_path_and_write_node_t> && offsetof(pm_constant_path_and_write_node_t, base) == 0, "pm_constant_path_and_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_path_node_t to PM_CONSTANT_PATH_NODE. */
+template <> struct node_type<pm_constant_path_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_PATH_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_path_node_t> && offsetof(pm_constant_path_node_t, base) == 0, "pm_constant_path_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_path_operator_write_node_t to PM_CONSTANT_PATH_OPERATOR_WRITE_NODE. */
+template <> struct node_type<pm_constant_path_operator_write_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_PATH_OPERATOR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_path_operator_write_node_t> && offsetof(pm_constant_path_operator_write_node_t, base) == 0, "pm_constant_path_operator_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_path_or_write_node_t to PM_CONSTANT_PATH_OR_WRITE_NODE. */
+template <> struct node_type<pm_constant_path_or_write_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_PATH_OR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_path_or_write_node_t> && offsetof(pm_constant_path_or_write_node_t, base) == 0, "pm_constant_path_or_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_path_target_node_t to PM_CONSTANT_PATH_TARGET_NODE. */
+template <> struct node_type<pm_constant_path_target_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_PATH_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_path_target_node_t> && offsetof(pm_constant_path_target_node_t, base) == 0, "pm_constant_path_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_path_write_node_t to PM_CONSTANT_PATH_WRITE_NODE. */
+template <> struct node_type<pm_constant_path_write_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_PATH_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_path_write_node_t> && offsetof(pm_constant_path_write_node_t, base) == 0, "pm_constant_path_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_read_node_t to PM_CONSTANT_READ_NODE. */
+template <> struct node_type<pm_constant_read_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_READ_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_read_node_t> && offsetof(pm_constant_read_node_t, base) == 0, "pm_constant_read_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_target_node_t to PM_CONSTANT_TARGET_NODE. */
+template <> struct node_type<pm_constant_target_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_target_node_t> && offsetof(pm_constant_target_node_t, base) == 0, "pm_constant_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_constant_write_node_t to PM_CONSTANT_WRITE_NODE. */
+template <> struct node_type<pm_constant_write_node_t> : std::integral_constant<pm_node_type_t, PM_CONSTANT_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_constant_write_node_t> && offsetof(pm_constant_write_node_t, base) == 0, "pm_constant_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_def_node_t to PM_DEF_NODE. */
+template <> struct node_type<pm_def_node_t> : std::integral_constant<pm_node_type_t, PM_DEF_NODE> {};
+static_assert(std::is_standard_layout_v<pm_def_node_t> && offsetof(pm_def_node_t, base) == 0, "pm_def_node_t must begin with its pm_node_t");
+
+/** Maps pm_defined_node_t to PM_DEFINED_NODE. */
+template <> struct node_type<pm_defined_node_t> : std::integral_constant<pm_node_type_t, PM_DEFINED_NODE> {};
+static_assert(std::is_standard_layout_v<pm_defined_node_t> && offsetof(pm_defined_node_t, base) == 0, "pm_defined_node_t must begin with its pm_node_t");
+
+/** Maps pm_else_node_t to PM_ELSE_NODE. */
+template <> struct node_type<pm_else_node_t> : std::integral_constant<pm_node_type_t, PM_ELSE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_else_node_t> && offsetof(pm_else_node_t, base) == 0, "pm_else_node_t must begin with its pm_node_t");
+
+/** Maps pm_embedded_statements_node_t to PM_EMBEDDED_STATEMENTS_NODE. */
+template <> struct node_type<pm_embedded_statements_node_t> : std::integral_constant<pm_node_type_t, PM_EMBEDDED_STATEMENTS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_embedded_statements_node_t> && offsetof(pm_embedded_statements_node_t, base) == 0, "pm_embedded_statements_node_t must begin with its pm_node_t");
+
+/** Maps pm_embedded_variable_node_t to PM_EMBEDDED_VARIABLE_NODE. */
+template <> struct node_type<pm_embedded_variable_node_t> : std::integral_constant<pm_node_type_t, PM_EMBEDDED_VARIABLE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_embedded_variable_node_t> && offsetof(pm_embedded_variable_node_t, base) == 0, "pm_embedded_variable_node_t must begin with its pm_node_t");
+
+/** Maps pm_ensure_node_t to PM_ENSURE_NODE. */
+template <> struct node_type<pm_ensure_node_t> : std::integral_constant<pm_node_type_t, PM_ENSURE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_ensure_node_t> && offsetof(pm_ensure_node_t, base) == 0, "pm_ensure_node_t must begin with its pm_node_t");
+
+/** Maps pm_error_recovery_node_t to PM_ERROR_RECOVERY_NODE. */
+template <> struct node_type<pm_error_recovery_node_t> : std::integral_constant<pm_node_type_t, PM_ERROR_RECOVERY_NODE> {};
+static_assert(std::is_standard_layout_v<pm_error_recovery_node_t> && offsetof(pm_error_recovery_node_t, base) == 0, "pm_error_recovery_node_t must begin with its pm_node_t");
+
+/** Maps pm_false_node_t to PM_FALSE_NODE. */
+template <> struct node_type<pm_false_node_t> : std::integral_constant<pm_node_type_t, PM_FALSE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_false_node_t> && offsetof(pm_false_node_t, base) == 0, "pm_false_node_t must begin with its pm_node_t");
+
+/** Maps pm_find_pattern_node_t to PM_FIND_PATTERN_NODE. */
+template <> struct node_type<pm_find_pattern_node_t> : std::integral_constant<pm_node_type_t, PM_FIND_PATTERN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_find_pattern_node_t> && offsetof(pm_find_pattern_node_t, base) == 0, "pm_find_pattern_node_t must begin with its pm_node_t");
+
+/** Maps pm_flip_flop_node_t to PM_FLIP_FLOP_NODE. */
+template <> struct node_type<pm_flip_flop_node_t> : std::integral_constant<pm_node_type_t, PM_FLIP_FLOP_NODE> {};
+static_assert(std::is_standard_layout_v<pm_flip_flop_node_t> && offsetof(pm_flip_flop_node_t, base) == 0, "pm_flip_flop_node_t must begin with its pm_node_t");
+
+/** Maps pm_float_node_t to PM_FLOAT_NODE. */
+template <> struct node_type<pm_float_node_t> : std::integral_constant<pm_node_type_t, PM_FLOAT_NODE> {};
+static_assert(std::is_standard_layout_v<pm_float_node_t> && offsetof(pm_float_node_t, base) == 0, "pm_float_node_t must begin with its pm_node_t");
+
+/** Maps pm_for_node_t to PM_FOR_NODE. */
+template <> struct node_type<pm_for_node_t> : std::integral_constant<pm_node_type_t, PM_FOR_NODE> {};
+static_assert(std::is_standard_layout_v<pm_for_node_t> && offsetof(pm_for_node_t, base) == 0, "pm_for_node_t must begin with its pm_node_t");
+
+/** Maps pm_forwarding_arguments_node_t to PM_FORWARDING_ARGUMENTS_NODE. */
+template <> struct node_type<pm_forwarding_arguments_node_t> : std::integral_constant<pm_node_type_t, PM_FORWARDING_ARGUMENTS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_forwarding_arguments_node_t> && offsetof(pm_forwarding_arguments_node_t, base) == 0, "pm_forwarding_arguments_node_t must begin with its pm_node_t");
+
+/** Maps pm_forwarding_parameter_node_t to PM_FORWARDING_PARAMETER_NODE. */
+template <> struct node_type<pm_forwarding_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_FORWARDING_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_forwarding_parameter_node_t> && offsetof(pm_forwarding_parameter_node_t, base) == 0, "pm_forwarding_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_forwarding_super_node_t to PM_FORWARDING_SUPER_NODE. */
+template <> struct node_type<pm_forwarding_super_node_t> : std::integral_constant<pm_node_type_t, PM_FORWARDING_SUPER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_forwarding_super_node_t> && offsetof(pm_forwarding_super_node_t, base) == 0, "pm_forwarding_super_node_t must begin with its pm_node_t");
+
+/** Maps pm_global_variable_and_write_node_t to PM_GLOBAL_VARIABLE_AND_WRITE_NODE. */
+template <> struct node_type<pm_global_variable_and_write_node_t> : std::integral_constant<pm_node_type_t, PM_GLOBAL_VARIABLE_AND_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_global_variable_and_write_node_t> && offsetof(pm_global_variable_and_write_node_t, base) == 0, "pm_global_variable_and_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_global_variable_operator_write_node_t to PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE. */
+template <> struct node_type<pm_global_variable_operator_write_node_t> : std::integral_constant<pm_node_type_t, PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_global_variable_operator_write_node_t> && offsetof(pm_global_variable_operator_write_node_t, base) == 0, "pm_global_variable_operator_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_global_variable_or_write_node_t to PM_GLOBAL_VARIABLE_OR_WRITE_NODE. */
+template <> struct node_type<pm_global_variable_or_write_node_t> : std::integral_constant<pm_node_type_t, PM_GLOBAL_VARIABLE_OR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_global_variable_or_write_node_t> && offsetof(pm_global_variable_or_write_node_t, base) == 0, "pm_global_variable_or_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_global_variable_read_node_t to PM_GLOBAL_VARIABLE_READ_NODE. */
+template <> struct node_type<pm_global_variable_read_node_t> : std::integral_constant<pm_node_type_t, PM_GLOBAL_VARIABLE_READ_NODE> {};
+static_assert(std::is_standard_layout_v<pm_global_variable_read_node_t> && offsetof(pm_global_variable_read_node_t, base) == 0, "pm_global_variable_read_node_t must begin with its pm_node_t");
+
+/** Maps pm_global_variable_target_node_t to PM_GLOBAL_VARIABLE_TARGET_NODE. */
+template <> struct node_type<pm_global_variable_target_node_t> : std::integral_constant<pm_node_type_t, PM_GLOBAL_VARIABLE_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_global_variable_target_node_t> && offsetof(pm_global_variable_target_node_t, base) == 0, "pm_global_variable_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_global_variable_write_node_t to PM_GLOBAL_VARIABLE_WRITE_NODE. */
+template <> struct node_type<pm_global_variable_write_node_t> : std::integral_constant<pm_node_type_t, PM_GLOBAL_VARIABLE_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_global_variable_write_node_t> && offsetof(pm_global_variable_write_node_t, base) == 0, "pm_global_variable_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_hash_node_t to PM_HASH_NODE. */
+template <> struct node_type<pm_hash_node_t> : std::integral_constant<pm_node_type_t, PM_HASH_NODE> {};
+static_assert(std::is_standard_layout_v<pm_hash_node_t> && offsetof(pm_hash_node_t, base) == 0, "pm_hash_node_t must begin with its pm_node_t");
+
+/** Maps pm_hash_pattern_node_t to PM_HASH_PATTERN_NODE. */
+template <> struct node_type<pm_hash_pattern_node_t> : std::integral_constant<pm_node_type_t, PM_HASH_PATTERN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_hash_pattern_node_t> && offsetof(pm_hash_pattern_node_t, base) == 0, "pm_hash_pattern_node_t must begin with its pm_node_t");
+
+/** Maps pm_if_node_t to PM_IF_NODE. */
+template <> struct node_type<pm_if_node_t> : std::integral_constant<pm_node_type_t, PM_IF_NODE> {};
+static_assert(std::is_standard_layout_v<pm_if_node_t> && offsetof(pm_if_node_t, base) == 0, "pm_if_node_t must begin with its pm_node_t");
+
+/** Maps pm_imaginary_node_t to PM_IMAGINARY_NODE. */
+template <> struct node_type<pm_imaginary_node_t> : std::integral_constant<pm_node_type_t, PM_IMAGINARY_NODE> {};
+static_assert(std::is_standard_layout_v<pm_imaginary_node_t> && offsetof(pm_imaginary_node_t, base) == 0, "pm_imaginary_node_t must begin with its pm_node_t");
+
+/** Maps pm_implicit_node_t to PM_IMPLICIT_NODE. */
+template <> struct node_type<pm_implicit_node_t> : std::integral_constant<pm_node_type_t, PM_IMPLICIT_NODE> {};
+static_assert(std::is_standard_layout_v<pm_implicit_node_t> && offsetof(pm_implicit_node_t, base) == 0, "pm_implicit_node_t must begin with its pm_node_t");
+
+/** Maps pm_implicit_rest_node_t to PM_IMPLICIT_REST_NODE. */
+template <> struct node_type<pm_implicit_rest_node_t> : std::integral_constant<pm_node_type_t, PM_IMPLICIT_REST_NODE> {};
+static_assert(std::is_standard_layout_v<pm_implicit_rest_node_t> && offsetof(pm_implicit_rest_node_t, base) == 0, "pm_implicit_rest_node_t must begin with its pm_node_t");
+
+/** Maps pm_in_node_t to PM_IN_NODE. */
+template <> struct node_type<pm_in_node_t> : std::integral_constant<pm_node_type_t, PM_IN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_in_node_t> && offsetof(pm_in_node_t, base) == 0, "pm_in_node_t must begin with its pm_node_t");
+
+/** Maps pm_index_and_write_node_t to PM_INDEX_AND_WRITE_NODE. */
+template <> struct node_type<pm_index_and_write_node_t> : std::integral_constant<pm_node_type_t, PM_INDEX_AND_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_index_and_write_node_t> && offsetof(pm_index_and_write_node_t, base) == 0, "pm_index_and_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_index_operator_write_node_t to PM_INDEX_OPERATOR_WRITE_NODE. */
+template <> struct node_type<pm_index_operator_write_node_t> : std::integral_constant<pm_node_type_t, PM_INDEX_OPERATOR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_index_operator_write_node_t> && offsetof(pm_index_operator_write_node_t, base) == 0, "pm_index_operator_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_index_or_write_node_t to PM_INDEX_OR_WRITE_NODE. */
+template <> struct node_type<pm_index_or_write_node_t> : std::integral_constant<pm_node_type_t, PM_INDEX_OR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_index_or_write_node_t> && offsetof(pm_index_or_write_node_t, base) == 0, "pm_index_or_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_index_target_node_t to PM_INDEX_TARGET_NODE. */
+template <> struct node_type<pm_index_target_node_t> : std::integral_constant<pm_node_type_t, PM_INDEX_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_index_target_node_t> && offsetof(pm_index_target_node_t, base) == 0, "pm_index_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_instance_variable_and_write_node_t to PM_INSTANCE_VARIABLE_AND_WRITE_NODE. */
+template <> struct node_type<pm_instance_variable_and_write_node_t> : std::integral_constant<pm_node_type_t, PM_INSTANCE_VARIABLE_AND_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_instance_variable_and_write_node_t> && offsetof(pm_instance_variable_and_write_node_t, base) == 0, "pm_instance_variable_and_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_instance_variable_operator_write_node_t to PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE. */
+template <> struct node_type<pm_instance_variable_operator_write_node_t> : std::integral_constant<pm_node_type_t, PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_instance_variable_operator_write_node_t> && offsetof(pm_instance_variable_operator_write_node_t, base) == 0, "pm_instance_variable_operator_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_instance_variable_or_write_node_t to PM_INSTANCE_VARIABLE_OR_WRITE_NODE. */
+template <> struct node_type<pm_instance_variable_or_write_node_t> : std::integral_constant<pm_node_type_t, PM_INSTANCE_VARIABLE_OR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_instance_variable_or_write_node_t> && offsetof(pm_instance_variable_or_write_node_t, base) == 0, "pm_instance_variable_or_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_instance_variable_read_node_t to PM_INSTANCE_VARIABLE_READ_NODE. */
+template <> struct node_type<pm_instance_variable_read_node_t> : std::integral_constant<pm_node_type_t, PM_INSTANCE_VARIABLE_READ_NODE> {};
+static_assert(std::is_standard_layout_v<pm_instance_variable_read_node_t> && offsetof(pm_instance_variable_read_node_t, base) == 0, "pm_instance_variable_read_node_t must begin with its pm_node_t");
+
+/** Maps pm_instance_variable_target_node_t to PM_INSTANCE_VARIABLE_TARGET_NODE. */
+template <> struct node_type<pm_instance_variable_target_node_t> : std::integral_constant<pm_node_type_t, PM_INSTANCE_VARIABLE_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_instance_variable_target_node_t> && offsetof(pm_instance_variable_target_node_t, base) == 0, "pm_instance_variable_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_instance_variable_write_node_t to PM_INSTANCE_VARIABLE_WRITE_NODE. */
+template <> struct node_type<pm_instance_variable_write_node_t> : std::integral_constant<pm_node_type_t, PM_INSTANCE_VARIABLE_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_instance_variable_write_node_t> && offsetof(pm_instance_variable_write_node_t, base) == 0, "pm_instance_variable_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_integer_node_t to PM_INTEGER_NODE. */
+template <> struct node_type<pm_integer_node_t> : std::integral_constant<pm_node_type_t, PM_INTEGER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_integer_node_t> && offsetof(pm_integer_node_t, base) == 0, "pm_integer_node_t must begin with its pm_node_t");
+
+/** Maps pm_interpolated_match_last_line_node_t to PM_INTERPOLATED_MATCH_LAST_LINE_NODE. */
+template <> struct node_type<pm_interpolated_match_last_line_node_t> : std::integral_constant<pm_node_type_t, PM_INTERPOLATED_MATCH_LAST_LINE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_interpolated_match_last_line_node_t> && offsetof(pm_interpolated_match_last_line_node_t, base) == 0, "pm_interpolated_match_last_line_node_t must begin with its pm_node_t");
+
+/** Maps pm_interpolated_regular_expression_node_t to PM_INTERPOLATED_REGULAR_EXPRESSION_NODE. */
+template <> struct node_type<pm_interpolated_regular_expression_node_t> : std::integral_constant<pm_node_type_t, PM_INTERPOLATED_REGULAR_EXPRESSION_NODE> {};
+static_assert(std::is_standard_layout_v<pm_interpolated_regular_expression_node_t> && offsetof(pm_interpolated_regular_expression_node_t, base) == 0, "pm_interpolated_regular_expression_node_t must begin with its pm_node_t");
+
+/** Maps pm_interpolated_string_node_t to PM_INTERPOLATED_STRING_NODE. */
+template <> struct node_type<pm_interpolated_string_node_t> : std::integral_constant<pm_node_type_t, PM_INTERPOLATED_STRING_NODE> {};
+static_assert(std::is_standard_layout_v<pm_interpolated_string_node_t> && offsetof(pm_interpolated_string_node_t, base) == 0, "pm_interpolated_string_node_t must begin with its pm_node_t");
+
+/** Maps pm_interpolated_symbol_node_t to PM_INTERPOLATED_SYMBOL_NODE. */
+template <> struct node_type<pm_interpolated_symbol_node_t> : std::integral_constant<pm_node_type_t, PM_INTERPOLATED_SYMBOL_NODE> {};
+static_assert(std::is_standard_layout_v<pm_interpolated_symbol_node_t> && offsetof(pm_interpolated_symbol_node_t, base) == 0, "pm_interpolated_symbol_node_t must begin with its pm_node_t");
+
+/** Maps pm_interpolated_x_string_node_t to PM_INTERPOLATED_X_STRING_NODE. */
+template <> struct node_type<pm_interpolated_x_string_node_t> : std::integral_constant<pm_node_type_t, PM_INTERPOLATED_X_STRING_NODE> {};
+static_assert(std::is_standard_layout_v<pm_interpolated_x_string_node_t> && offsetof(pm_interpolated_x_string_node_t, base) == 0, "pm_interpolated_x_string_node_t must begin with its pm_node_t");
+
+/** Maps pm_it_local_variable_read_node_t to PM_IT_LOCAL_VARIABLE_READ_NODE. */
+template <> struct node_type<pm_it_local_variable_read_node_t> : std::integral_constant<pm_node_type_t, PM_IT_LOCAL_VARIABLE_READ_NODE> {};
+static_assert(std::is_standard_layout_v<pm_it_local_variable_read_node_t> && offsetof(pm_it_local_variable_read_node_t, base) == 0, "pm_it_local_variable_read_node_t must begin with its pm_node_t");
+
+/** Maps pm_it_parameters_node_t to PM_IT_PARAMETERS_NODE. */
+template <> struct node_type<pm_it_parameters_node_t> : std::integral_constant<pm_node_type_t, PM_IT_PARAMETERS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_it_parameters_node_t> && offsetof(pm_it_parameters_node_t, base) == 0, "pm_it_parameters_node_t must begin with its pm_node_t");
+
+/** Maps pm_keyword_hash_node_t to PM_KEYWORD_HASH_NODE. */
+template <> struct node_type<pm_keyword_hash_node_t> : std::integral_constant<pm_node_type_t, PM_KEYWORD_HASH_NODE> {};
+static_assert(std::is_standard_layout_v<pm_keyword_hash_node_t> && offsetof(pm_keyword_hash_node_t, base) == 0, "pm_keyword_hash_node_t must begin with its pm_node_t");
+
+/** Maps pm_keyword_rest_parameter_node_t to PM_KEYWORD_REST_PARAMETER_NODE. */
+template <> struct node_type<pm_keyword_rest_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_KEYWORD_REST_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_keyword_rest_parameter_node_t> && offsetof(pm_keyword_rest_parameter_node_t, base) == 0, "pm_keyword_rest_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_lambda_node_t to PM_LAMBDA_NODE. */
+template <> struct node_type<pm_lambda_node_t> : std::integral_constant<pm_node_type_t, PM_LAMBDA_NODE> {};
+static_assert(std::is_standard_layout_v<pm_lambda_node_t> && offsetof(pm_lambda_node_t, base) == 0, "pm_lambda_node_t must begin with its pm_node_t");
+
+/** Maps pm_local_variable_and_write_node_t to PM_LOCAL_VARIABLE_AND_WRITE_NODE. */
+template <> struct node_type<pm_local_variable_and_write_node_t> : std::integral_constant<pm_node_type_t, PM_LOCAL_VARIABLE_AND_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_local_variable_and_write_node_t> && offsetof(pm_local_variable_and_write_node_t, base) == 0, "pm_local_variable_and_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_local_variable_operator_write_node_t to PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE. */
+template <> struct node_type<pm_local_variable_operator_write_node_t> : std::integral_constant<pm_node_type_t, PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_local_variable_operator_write_node_t> && offsetof(pm_local_variable_operator_write_node_t, base) == 0, "pm_local_variable_operator_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_local_variable_or_write_node_t to PM_LOCAL_VARIABLE_OR_WRITE_NODE. */
+template <> struct node_type<pm_local_variable_or_write_node_t> : std::integral_constant<pm_node_type_t, PM_LOCAL_VARIABLE_OR_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_local_variable_or_write_node_t> && offsetof(pm_local_variable_or_write_node_t, base) == 0, "pm_local_variable_or_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_local_variable_read_node_t to PM_LOCAL_VARIABLE_READ_NODE. */
+template <> struct node_type<pm_local_variable_read_node_t> : std::integral_constant<pm_node_type_t, PM_LOCAL_VARIABLE_READ_NODE> {};
+static_assert(std::is_standard_layout_v<pm_local_variable_read_node_t> && offsetof(pm_local_variable_read_node_t, base) == 0, "pm_local_variable_read_node_t must begin with its pm_node_t");
+
+/** Maps pm_local_variable_target_node_t to PM_LOCAL_VARIABLE_TARGET_NODE. */
+template <> struct node_type<pm_local_variable_target_node_t> : std::integral_constant<pm_node_type_t, PM_LOCAL_VARIABLE_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_local_variable_target_node_t> && offsetof(pm_local_variable_target_node_t, base) == 0, "pm_local_variable_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_local_variable_write_node_t to PM_LOCAL_VARIABLE_WRITE_NODE. */
+template <> struct node_type<pm_local_variable_write_node_t> : std::integral_constant<pm_node_type_t, PM_LOCAL_VARIABLE_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_local_variable_write_node_t> && offsetof(pm_local_variable_write_node_t, base) == 0, "pm_local_variable_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_match_last_line_node_t to PM_MATCH_LAST_LINE_NODE. */
+template <> struct node_type<pm_match_last_line_node_t> : std::integral_constant<pm_node_type_t, PM_MATCH_LAST_LINE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_match_last_line_node_t> && offsetof(pm_match_last_line_node_t, base) == 0, "pm_match_last_line_node_t must begin with its pm_node_t");
+
+/** Maps pm_match_predicate_node_t to PM_MATCH_PREDICATE_NODE. */
+template <> struct node_type<pm_match_predicate_node_t> : std::integral_constant<pm_node_type_t, PM_MATCH_PREDICATE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_match_predicate_node_t> && offsetof(pm_match_predicate_node_t, base) == 0, "pm_match_predicate_node_t must begin with its pm_node_t");
+
+/** Maps pm_match_required_node_t to PM_MATCH_REQUIRED_NODE. */
+template <> struct node_type<pm_match_required_node_t> : std::integral_constant<pm_node_type_t, PM_MATCH_REQUIRED_NODE> {};
+static_assert(std::is_standard_layout_v<pm_match_required_node_t> && offsetof(pm_match_required_node_t, base) == 0, "pm_match_required_node_t must begin with its pm_node_t");
+
+/** Maps pm_match_write_node_t to PM_MATCH_WRITE_NODE. */
+template <> struct node_type<pm_match_write_node_t> : std::integral_constant<pm_node_type_t, PM_MATCH_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_match_write_node_t> && offsetof(pm_match_write_node_t, base) == 0, "pm_match_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_module_node_t to PM_MODULE_NODE. */
+template <> struct node_type<pm_module_node_t> : std::integral_constant<pm_node_type_t, PM_MODULE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_module_node_t> && offsetof(pm_module_node_t, base) == 0, "pm_module_node_t must begin with its pm_node_t");
+
+/** Maps pm_multi_target_node_t to PM_MULTI_TARGET_NODE. */
+template <> struct node_type<pm_multi_target_node_t> : std::integral_constant<pm_node_type_t, PM_MULTI_TARGET_NODE> {};
+static_assert(std::is_standard_layout_v<pm_multi_target_node_t> && offsetof(pm_multi_target_node_t, base) == 0, "pm_multi_target_node_t must begin with its pm_node_t");
+
+/** Maps pm_multi_write_node_t to PM_MULTI_WRITE_NODE. */
+template <> struct node_type<pm_multi_write_node_t> : std::integral_constant<pm_node_type_t, PM_MULTI_WRITE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_multi_write_node_t> && offsetof(pm_multi_write_node_t, base) == 0, "pm_multi_write_node_t must begin with its pm_node_t");
+
+/** Maps pm_next_node_t to PM_NEXT_NODE. */
+template <> struct node_type<pm_next_node_t> : std::integral_constant<pm_node_type_t, PM_NEXT_NODE> {};
+static_assert(std::is_standard_layout_v<pm_next_node_t> && offsetof(pm_next_node_t, base) == 0, "pm_next_node_t must begin with its pm_node_t");
+
+/** Maps pm_nil_node_t to PM_NIL_NODE. */
+template <> struct node_type<pm_nil_node_t> : std::integral_constant<pm_node_type_t, PM_NIL_NODE> {};
+static_assert(std::is_standard_layout_v<pm_nil_node_t> && offsetof(pm_nil_node_t, base) == 0, "pm_nil_node_t must begin with its pm_node_t");
+
+/** Maps pm_no_block_parameter_node_t to PM_NO_BLOCK_PARAMETER_NODE. */
+template <> struct node_type<pm_no_block_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_NO_BLOCK_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_no_block_parameter_node_t> && offsetof(pm_no_block_parameter_node_t, base) == 0, "pm_no_block_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_no_keywords_parameter_node_t to PM_NO_KEYWORDS_PARAMETER_NODE. */
+template <> struct node_type<pm_no_keywords_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_NO_KEYWORDS_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_no_keywords_parameter_node_t> && offsetof(pm_no_keywords_parameter_node_t, base) == 0, "pm_no_keywords_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_numbered_parameters_node_t to PM_NUMBERED_PARAMETERS_NODE. */
+template <> struct node_type<pm_numbered_parameters_node_t> : std::integral_constant<pm_node_type_t, PM_NUMBERED_PARAMETERS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_numbered_parameters_node_t> && offsetof(pm_numbered_parameters_node_t, base) == 0, "pm_numbered_parameters_node_t must begin with its pm_node_t");
+
+/** Maps pm_numbered_reference_read_node_t to PM_NUMBERED_REFERENCE_READ_NODE. */
+template <> struct node_type<pm_numbered_reference_read_node_t> : std::integral_constant<pm_node_type_t, PM_NUMBERED_REFERENCE_READ_NODE> {};
+static_assert(std::is_standard_layout_v<pm_numbered_reference_read_node_t> && offsetof(pm_numbered_reference_read_node_t, base) == 0, "pm_numbered_reference_read_node_t must begin with its pm_node_t");
+
+/** Maps pm_optional_keyword_parameter_node_t to PM_OPTIONAL_KEYWORD_PARAMETER_NODE. */
+template <> struct node_type<pm_optional_keyword_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_OPTIONAL_KEYWORD_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_optional_keyword_parameter_node_t> && offsetof(pm_optional_keyword_parameter_node_t, base) == 0, "pm_optional_keyword_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_optional_parameter_node_t to PM_OPTIONAL_PARAMETER_NODE. */
+template <> struct node_type<pm_optional_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_OPTIONAL_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_optional_parameter_node_t> && offsetof(pm_optional_parameter_node_t, base) == 0, "pm_optional_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_or_node_t to PM_OR_NODE. */
+template <> struct node_type<pm_or_node_t> : std::integral_constant<pm_node_type_t, PM_OR_NODE> {};
+static_assert(std::is_standard_layout_v<pm_or_node_t> && offsetof(pm_or_node_t, base) == 0, "pm_or_node_t must begin with its pm_node_t");
+
+/** Maps pm_parameters_node_t to PM_PARAMETERS_NODE. */
+template <> struct node_type<pm_parameters_node_t> : std::integral_constant<pm_node_type_t, PM_PARAMETERS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_parameters_node_t> && offsetof(pm_parameters_node_t, base) == 0, "pm_parameters_node_t must begin with its pm_node_t");
+
+/** Maps pm_parentheses_node_t to PM_PARENTHESES_NODE. */
+template <> struct node_type<pm_parentheses_node_t> : std::integral_constant<pm_node_type_t, PM_PARENTHESES_NODE> {};
+static_assert(std::is_standard_layout_v<pm_parentheses_node_t> && offsetof(pm_parentheses_node_t, base) == 0, "pm_parentheses_node_t must begin with its pm_node_t");
+
+/** Maps pm_pinned_expression_node_t to PM_PINNED_EXPRESSION_NODE. */
+template <> struct node_type<pm_pinned_expression_node_t> : std::integral_constant<pm_node_type_t, PM_PINNED_EXPRESSION_NODE> {};
+static_assert(std::is_standard_layout_v<pm_pinned_expression_node_t> && offsetof(pm_pinned_expression_node_t, base) == 0, "pm_pinned_expression_node_t must begin with its pm_node_t");
+
+/** Maps pm_pinned_variable_node_t to PM_PINNED_VARIABLE_NODE. */
+template <> struct node_type<pm_pinned_variable_node_t> : std::integral_constant<pm_node_type_t, PM_PINNED_VARIABLE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_pinned_variable_node_t> && offsetof(pm_pinned_variable_node_t, base) == 0, "pm_pinned_variable_node_t must begin with its pm_node_t");
+
+/** Maps pm_post_execution_node_t to PM_POST_EXECUTION_NODE. */
+template <> struct node_type<pm_post_execution_node_t> : std::integral_constant<pm_node_type_t, PM_POST_EXECUTION_NODE> {};
+static_assert(std::is_standard_layout_v<pm_post_execution_node_t> && offsetof(pm_post_execution_node_t, base) == 0, "pm_post_execution_node_t must begin with its pm_node_t");
+
+/** Maps pm_pre_execution_node_t to PM_PRE_EXECUTION_NODE. */
+template <> struct node_type<pm_pre_execution_node_t> : std::integral_constant<pm_node_type_t, PM_PRE_EXECUTION_NODE> {};
+static_assert(std::is_standard_layout_v<pm_pre_execution_node_t> && offsetof(pm_pre_execution_node_t, base) == 0, "pm_pre_execution_node_t must begin with its pm_node_t");
+
+/** Maps pm_program_node_t to PM_PROGRAM_NODE. */
+template <> struct node_type<pm_program_node_t> : std::integral_constant<pm_node_type_t, PM_PROGRAM_NODE> {};
+static_assert(std::is_standard_layout_v<pm_program_node_t> && offsetof(pm_program_node_t, base) == 0, "pm_program_node_t must begin with its pm_node_t");
+
+/** Maps pm_range_node_t to PM_RANGE_NODE. */
+template <> struct node_type<pm_range_node_t> : std::integral_constant<pm_node_type_t, PM_RANGE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_range_node_t> && offsetof(pm_range_node_t, base) == 0, "pm_range_node_t must begin with its pm_node_t");
+
+/** Maps pm_rational_node_t to PM_RATIONAL_NODE. */
+template <> struct node_type<pm_rational_node_t> : std::integral_constant<pm_node_type_t, PM_RATIONAL_NODE> {};
+static_assert(std::is_standard_layout_v<pm_rational_node_t> && offsetof(pm_rational_node_t, base) == 0, "pm_rational_node_t must begin with its pm_node_t");
+
+/** Maps pm_redo_node_t to PM_REDO_NODE. */
+template <> struct node_type<pm_redo_node_t> : std::integral_constant<pm_node_type_t, PM_REDO_NODE> {};
+static_assert(std::is_standard_layout_v<pm_redo_node_t> && offsetof(pm_redo_node_t, base) == 0, "pm_redo_node_t must begin with its pm_node_t");
+
+/** Maps pm_regular_expression_node_t to PM_REGULAR_EXPRESSION_NODE. */
+template <> struct node_type<pm_regular_expression_node_t> : std::integral_constant<pm_node_type_t, PM_REGULAR_EXPRESSION_NODE> {};
+static_assert(std::is_standard_layout_v<pm_regular_expression_node_t> && offsetof(pm_regular_expression_node_t, base) == 0, "pm_regular_expression_node_t must begin with its pm_node_t");
+
+/** Maps pm_required_keyword_parameter_node_t to PM_REQUIRED_KEYWORD_PARAMETER_NODE. */
+template <> struct node_type<pm_required_keyword_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_REQUIRED_KEYWORD_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_required_keyword_parameter_node_t> && offsetof(pm_required_keyword_parameter_node_t, base) == 0, "pm_required_keyword_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_required_parameter_node_t to PM_REQUIRED_PARAMETER_NODE. */
+template <> struct node_type<pm_required_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_REQUIRED_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_required_parameter_node_t> && offsetof(pm_required_parameter_node_t, base) == 0, "pm_required_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_rescue_modifier_node_t to PM_RESCUE_MODIFIER_NODE. */
+template <> struct node_type<pm_rescue_modifier_node_t> : std::integral_constant<pm_node_type_t, PM_RESCUE_MODIFIER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_rescue_modifier_node_t> && offsetof(pm_rescue_modifier_node_t, base) == 0, "pm_rescue_modifier_node_t must begin with its pm_node_t");
+
+/** Maps pm_rescue_node_t to PM_RESCUE_NODE. */
+template <> struct node_type<pm_rescue_node_t> : std::integral_constant<pm_node_type_t, PM_RESCUE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_rescue_node_t> && offsetof(pm_rescue_node_t, base) == 0, "pm_rescue_node_t must begin with its pm_node_t");
+
+/** Maps pm_rest_parameter_node_t to PM_REST_PARAMETER_NODE. */
+template <> struct node_type<pm_rest_parameter_node_t> : std::integral_constant<pm_node_type_t, PM_REST_PARAMETER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_rest_parameter_node_t> && offsetof(pm_rest_parameter_node_t, base) == 0, "pm_rest_parameter_node_t must begin with its pm_node_t");
+
+/** Maps pm_retry_node_t to PM_RETRY_NODE. */
+template <> struct node_type<pm_retry_node_t> : std::integral_constant<pm_node_type_t, PM_RETRY_NODE> {};
+static_assert(std::is_standard_layout_v<pm_retry_node_t> && offsetof(pm_retry_node_t, base) == 0, "pm_retry_node_t must begin with its pm_node_t");
+
+/** Maps pm_return_node_t to PM_RETURN_NODE. */
+template <> struct node_type<pm_return_node_t> : std::integral_constant<pm_node_type_t, PM_RETURN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_return_node_t> && offsetof(pm_return_node_t, base) == 0, "pm_return_node_t must begin with its pm_node_t");
+
+/** Maps pm_self_node_t to PM_SELF_NODE. */
+template <> struct node_type<pm_self_node_t> : std::integral_constant<pm_node_type_t, PM_SELF_NODE> {};
+static_assert(std::is_standard_layout_v<pm_self_node_t> && offsetof(pm_self_node_t, base) == 0, "pm_self_node_t must begin with its pm_node_t");
+
+/** Maps pm_shareable_constant_node_t to PM_SHAREABLE_CONSTANT_NODE. */
+template <> struct node_type<pm_shareable_constant_node_t> : std::integral_constant<pm_node_type_t, PM_SHAREABLE_CONSTANT_NODE> {};
+static_assert(std::is_standard_layout_v<pm_shareable_constant_node_t> && offsetof(pm_shareable_constant_node_t, base) == 0, "pm_shareable_constant_node_t must begin with its pm_node_t");
+
+/** Maps pm_singleton_class_node_t to PM_SINGLETON_CLASS_NODE. */
+template <> struct node_type<pm_singleton_class_node_t> : std::integral_constant<pm_node_type_t, PM_SINGLETON_CLASS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_singleton_class_node_t> && offsetof(pm_singleton_class_node_t, base) == 0, "pm_singleton_class_node_t must begin with its pm_node_t");
+
+/** Maps pm_source_encoding_node_t to PM_SOURCE_ENCODING_NODE. */
+template <> struct node_type<pm_source_encoding_node_t> : std::integral_constant<pm_node_type_t, PM_SOURCE_ENCODING_NODE> {};
+static_assert(std::is_standard_layout_v<pm_source_encoding_node_t> && offsetof(pm_source_encoding_node_t, base) == 0, "pm_source_encoding_node_t must begin with its pm_node_t");
+
+/** Maps pm_source_file_node_t to PM_SOURCE_FILE_NODE. */
+template <> struct node_type<pm_source_file_node_t> : std::integral_constant<pm_node_type_t, PM_SOURCE_FILE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_source_file_node_t> && offsetof(pm_source_file_node_t, base) == 0, "pm_source_file_node_t must begin with its pm_node_t");
+
+/** Maps pm_source_line_node_t to PM_SOURCE_LINE_NODE. */
+template <> struct node_type<pm_source_line_node_t> : std::integral_constant<pm_node_type_t, PM_SOURCE_LINE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_source_line_node_t> && offsetof(pm_source_line_node_t, base) == 0, "pm_source_line_node_t must begin with its pm_node_t");
+
+/** Maps pm_splat_node_t to PM_SPLAT_NODE. */
+template <> struct node_type<pm_splat_node_t> : std::integral_constant<pm_node_type_t, PM_SPLAT_NODE> {};
+static_assert(std::is_standard_layout_v<pm_splat_node_t> && offsetof(pm_splat_node_t, base) == 0, "pm_splat_node_t must begin with its pm_node_t");
+
+/** Maps pm_statements_node_t to PM_STATEMENTS_NODE. */
+template <> struct node_type<pm_statements_node_t> : std::integral_constant<pm_node_type_t, PM_STATEMENTS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_statements_node_t> && offsetof(pm_statements_node_t, base) == 0, "pm_statements_node_t must begin with its pm_node_t");
+
+/** Maps pm_string_node_t to PM_STRING_NODE. */
+template <> struct node_type<pm_string_node_t> : std::integral_constant<pm_node_type_t, PM_STRING_NODE> {};
+static_assert(std::is_standard_layout_v<pm_string_node_t> && offsetof(pm_string_node_t, base) == 0, "pm_string_node_t must begin with its pm_node_t");
+
+/** Maps pm_super_node_t to PM_SUPER_NODE. */
+template <> struct node_type<pm_super_node_t> : std::integral_constant<pm_node_type_t, PM_SUPER_NODE> {};
+static_assert(std::is_standard_layout_v<pm_super_node_t> && offsetof(pm_super_node_t, base) == 0, "pm_super_node_t must begin with its pm_node_t");
+
+/** Maps pm_symbol_node_t to PM_SYMBOL_NODE. */
+template <> struct node_type<pm_symbol_node_t> : std::integral_constant<pm_node_type_t, PM_SYMBOL_NODE> {};
+static_assert(std::is_standard_layout_v<pm_symbol_node_t> && offsetof(pm_symbol_node_t, base) == 0, "pm_symbol_node_t must begin with its pm_node_t");
+
+/** Maps pm_true_node_t to PM_TRUE_NODE. */
+template <> struct node_type<pm_true_node_t> : std::integral_constant<pm_node_type_t, PM_TRUE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_true_node_t> && offsetof(pm_true_node_t, base) == 0, "pm_true_node_t must begin with its pm_node_t");
+
+/** Maps pm_undef_node_t to PM_UNDEF_NODE. */
+template <> struct node_type<pm_undef_node_t> : std::integral_constant<pm_node_type_t, PM_UNDEF_NODE> {};
+static_assert(std::is_standard_layout_v<pm_undef_node_t> && offsetof(pm_undef_node_t, base) == 0, "pm_undef_node_t must begin with its pm_node_t");
+
+/** Maps pm_unless_node_t to PM_UNLESS_NODE. */
+template <> struct node_type<pm_unless_node_t> : std::integral_constant<pm_node_type_t, PM_UNLESS_NODE> {};
+static_assert(std::is_standard_layout_v<pm_unless_node_t> && offsetof(pm_unless_node_t, base) == 0, "pm_unless_node_t must begin with its pm_node_t");
+
+/** Maps pm_until_node_t to PM_UNTIL_NODE. */
+template <> struct node_type<pm_until_node_t> : std::integral_constant<pm_node_type_t, PM_UNTIL_NODE> {};
+static_assert(std::is_standard_layout_v<pm_until_node_t> && offsetof(pm_until_node_t, base) == 0, "pm_until_node_t must begin with its pm_node_t");
+
+/** Maps pm_when_node_t to PM_WHEN_NODE. */
+template <> struct node_type<pm_when_node_t> : std::integral_constant<pm_node_type_t, PM_WHEN_NODE> {};
+static_assert(std::is_standard_layout_v<pm_when_node_t> && offsetof(pm_when_node_t, base) == 0, "pm_when_node_t must begin with its pm_node_t");
+
+/** Maps pm_while_node_t to PM_WHILE_NODE. */
+template <> struct node_type<pm_while_node_t> : std::integral_constant<pm_node_type_t, PM_WHILE_NODE> {};
+static_assert(std::is_standard_layout_v<pm_while_node_t> && offsetof(pm_while_node_t, base) == 0, "pm_while_node_t must begin with its pm_node_t");
+
+/** Maps pm_x_string_node_t to PM_X_STRING_NODE. */
+template <> struct node_type<pm_x_string_node_t> : std::integral_constant<pm_node_type_t, PM_X_STRING_NODE> {};
+static_assert(std::is_standard_layout_v<pm_x_string_node_t> && offsetof(pm_x_string_node_t, base) == 0, "pm_x_string_node_t must begin with its pm_node_t");
+
+/** Maps pm_yield_node_t to PM_YIELD_NODE. */
+template <> struct node_type<pm_yield_node_t> : std::integral_constant<pm_node_type_t, PM_YIELD_NODE> {};
+static_assert(std::is_standard_layout_v<pm_yield_node_t> && offsetof(pm_yield_node_t, base) == 0, "pm_yield_node_t must begin with its pm_node_t");
+
+}
+
+#endif