def to_interpolated

InterpolatedStringNode.new(

source,

location,

frozen? ? InterpolatedStringNodeFlags::FROZEN : 0,

opening_loc,

def to_interpolated

InterpolatedXStringNode.new(

source,

location,

flags,

opening_loc,

closing_loc

)

end

deprecated("value", "numerator", "denominator")

if denominator == 1

else

end

end

end

# continue to supply that API.

def child

deprecated("name", "name_loc")

end

end

# continue to supply that API.

def child

deprecated("name", "name_loc")

end

end

* it's considering.

*/

struct pm_parser {

/** The current state of the lexer. */

pm_lex_state_t lex_state;

* implement our own arena allocation.

*/

static inline void *

void *memory = xcalloc(1, size);

if (memory == NULL) {

fprintf(stderr, "Failed to allocate %d bytes\n", (int) size);

return memory;

}

/**

* Allocate a new MissingNode node.

*/

static pm_missing_node_t *

pm_missing_node_create(pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {

return node;

}

static pm_alias_global_variable_node_t *

pm_alias_global_variable_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *new_name, pm_node_t *old_name) {

assert(keyword->type == PM_TOKEN_KEYWORD_ALIAS);

*node = (pm_alias_global_variable_node_t) {

{

.type = PM_ALIAS_GLOBAL_VARIABLE_NODE,

.location = {

.start = keyword->start,

.end = old_name->location.end

static pm_alias_method_node_t *

pm_alias_method_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *new_name, pm_node_t *old_name) {

assert(keyword->type == PM_TOKEN_KEYWORD_ALIAS);

*node = (pm_alias_method_node_t) {

{

.type = PM_ALIAS_METHOD_NODE,

.location = {

.start = keyword->start,

.end = old_name->location.end

*/

static pm_alternation_pattern_node_t *

pm_alternation_pattern_node_create(pm_parser_t *parser, pm_node_t *left, pm_node_t *right, const pm_token_t *operator) {

*node = (pm_alternation_pattern_node_t) {

{

.type = PM_ALTERNATION_PATTERN_NODE,

.location = {

.start = left->location.start,

.end = right->location.end

pm_and_node_create(pm_parser_t *parser, pm_node_t *left, const pm_token_t *operator, pm_node_t *right) {

pm_assert_value_expression(parser, left);

*node = (pm_and_node_t) {

{

.type = PM_AND_NODE,

.location = {

.start = left->location.start,

.end = right->location.end

*/

static pm_arguments_node_t *

pm_arguments_node_create(pm_parser_t *parser) {

*node = (pm_arguments_node_t) {

{

.type = PM_ARGUMENTS_NODE,

.location = PM_LOCATION_NULL_VALUE(parser)

},

.arguments = { 0 }

*/

static pm_array_node_t *

pm_array_node_create(pm_parser_t *parser, const pm_token_t *opening) {

*node = (pm_array_node_t) {

{

.type = PM_ARRAY_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(opening)

},

.opening_loc = PM_OPTIONAL_LOCATION_TOKEN_VALUE(opening),

*/

static pm_array_pattern_node_t *

pm_array_pattern_node_node_list_create(pm_parser_t *parser, pm_node_list_t *nodes) {

*node = (pm_array_pattern_node_t) {

{

.type = PM_ARRAY_PATTERN_NODE,

.location = {

.start = nodes->nodes[0]->location.start,

.end = nodes->nodes[nodes->size - 1]->location.end

*/

static pm_array_pattern_node_t *

pm_array_pattern_node_rest_create(pm_parser_t *parser, pm_node_t *rest) {

*node = (pm_array_pattern_node_t) {

{

.type = PM_ARRAY_PATTERN_NODE,

.location = rest->location,

},

.constant = NULL,

*/

static pm_array_pattern_node_t *

pm_array_pattern_node_constant_create(pm_parser_t *parser, pm_node_t *constant, const pm_token_t *opening, const pm_token_t *closing) {

*node = (pm_array_pattern_node_t) {

{

.type = PM_ARRAY_PATTERN_NODE,

.location = {

.start = constant->location.start,

.end = closing->end

*/

static pm_array_pattern_node_t *

pm_array_pattern_node_empty_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {

*node = (pm_array_pattern_node_t) {

{

.type = PM_ARRAY_PATTERN_NODE,

.location = {

.start = opening->start,

.end = closing->end

*/

static pm_assoc_node_t *

pm_assoc_node_create(pm_parser_t *parser, pm_node_t *key, const pm_token_t *operator, pm_node_t *value) {

const uint8_t *end;

if (value != NULL && value->location.end > key->location.end) {

{

.type = PM_ASSOC_NODE,

.flags = flags,

.location = {

.start = key->location.start,

.end = end

static pm_assoc_splat_node_t *

pm_assoc_splat_node_create(pm_parser_t *parser, pm_node_t *value, const pm_token_t *operator) {

assert(operator->type == PM_TOKEN_USTAR_STAR);

*node = (pm_assoc_splat_node_t) {

{

.type = PM_ASSOC_SPLAT_NODE,

.location = {

.start = operator->start,

.end = value == NULL ? operator->end : value->location.end

static pm_back_reference_read_node_t *

pm_back_reference_read_node_create(pm_parser_t *parser, const pm_token_t *name) {

assert(name->type == PM_TOKEN_BACK_REFERENCE);

*node = (pm_back_reference_read_node_t) {

{

.type = PM_BACK_REFERENCE_READ_NODE,

.location = PM_LOCATION_TOKEN_VALUE(name),

},

.name = pm_parser_constant_id_token(parser, name)

*/

static pm_begin_node_t *

pm_begin_node_create(pm_parser_t *parser, const pm_token_t *begin_keyword, pm_statements_node_t *statements) {

*node = (pm_begin_node_t) {

{

.type = PM_BEGIN_NODE,

.location = {

.start = begin_keyword->start,

.end = statements == NULL ? begin_keyword->end : statements->base.location.end

*/

static pm_block_argument_node_t *

pm_block_argument_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *expression) {

*node = (pm_block_argument_node_t) {

{

.type = PM_BLOCK_ARGUMENT_NODE,

.location = {

.start = operator->start,

.end = expression == NULL ? operator->end : expression->location.end

*/

static pm_block_node_t *

pm_block_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *opening, pm_node_t *parameters, pm_node_t *body, const pm_token_t *closing) {

*node = (pm_block_node_t) {

{

.type = PM_BLOCK_NODE,

.location = { .start = opening->start, .end = closing->end },

},

.locals = *locals,

static pm_block_parameter_node_t *

pm_block_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, const pm_token_t *operator) {

assert(operator->type == PM_TOKEN_NOT_PROVIDED || operator->type == PM_TOKEN_UAMPERSAND || operator->type == PM_TOKEN_AMPERSAND);

*node = (pm_block_parameter_node_t) {

{

.type = PM_BLOCK_PARAMETER_NODE,

.location = {

.start = operator->start,

.end = (name->type == PM_TOKEN_NOT_PROVIDED ? operator->end : name->end)

*/

static pm_block_parameters_node_t *

pm_block_parameters_node_create(pm_parser_t *parser, pm_parameters_node_t *parameters, const pm_token_t *opening) {

const uint8_t *start;

if (opening->type != PM_TOKEN_NOT_PROVIDED) {

*node = (pm_block_parameters_node_t) {

{

.type = PM_BLOCK_PARAMETERS_NODE,

.location = {

.start = start,

.end = end

*/

static pm_block_local_variable_node_t *

pm_block_local_variable_node_create(pm_parser_t *parser, const pm_token_t *name) {

*node = (pm_block_local_variable_node_t) {

{

.type = PM_BLOCK_LOCAL_VARIABLE_NODE,

.location = PM_LOCATION_TOKEN_VALUE(name),

},

.name = pm_parser_constant_id_token(parser, name)

static pm_break_node_t *

pm_break_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {

assert(keyword->type == PM_TOKEN_KEYWORD_BREAK);

*node = (pm_break_node_t) {

{

.type = PM_BREAK_NODE,

.location = {

.start = keyword->start,

.end = (arguments == NULL ? keyword->end : arguments->base.location.end)

*/

static pm_call_node_t *

pm_call_node_create(pm_parser_t *parser, pm_node_flags_t flags) {

*node = (pm_call_node_t) {

{

.type = PM_CALL_NODE,

.flags = flags,

.location = PM_LOCATION_NULL_VALUE(parser),

},

.receiver = NULL,

pm_call_and_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(target->block == NULL);

assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);

*node = (pm_call_and_write_node_t) {

{

.type = PM_CALL_AND_WRITE_NODE,

.flags = target->base.flags,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_index_and_write_node_t *

pm_index_and_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);

pm_index_arguments_check(parser, target->arguments, target->block);

{

.type = PM_INDEX_AND_WRITE_NODE,

.flags = target->base.flags,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_call_operator_write_node_t *

pm_call_operator_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(target->block == NULL);

*node = (pm_call_operator_write_node_t) {

{

.type = PM_CALL_OPERATOR_WRITE_NODE,

.flags = target->base.flags,

.location = {

.start = target->base.location.start,

.end = value->location.end

*/

static pm_index_operator_write_node_t *

pm_index_operator_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {

pm_index_arguments_check(parser, target->arguments, target->block);

{

.type = PM_INDEX_OPERATOR_WRITE_NODE,

.flags = target->base.flags,

.location = {

.start = target->base.location.start,

.end = value->location.end

pm_call_or_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(target->block == NULL);

assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);

*node = (pm_call_or_write_node_t) {

{

.type = PM_CALL_OR_WRITE_NODE,

.flags = target->base.flags,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_index_or_write_node_t *

pm_index_or_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);

pm_index_arguments_check(parser, target->arguments, target->block);

{

.type = PM_INDEX_OR_WRITE_NODE,

.flags = target->base.flags,

.location = {

.start = target->base.location.start,

.end = value->location.end

*/

static pm_call_target_node_t *

pm_call_target_node_create(pm_parser_t *parser, pm_call_node_t *target) {

*node = (pm_call_target_node_t) {

{

.type = PM_CALL_TARGET_NODE,

.flags = target->base.flags,

.location = target->base.location

},

.receiver = target->receiver,

*/

static pm_index_target_node_t *

pm_index_target_node_create(pm_parser_t *parser, pm_call_node_t *target) {

pm_node_flags_t flags = target->base.flags;

pm_index_arguments_check(parser, target->arguments, target->block);

{

.type = PM_INDEX_TARGET_NODE,

.flags = flags | PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE,

.location = target->base.location

},

.receiver = target->receiver,

*/

static pm_capture_pattern_node_t *

pm_capture_pattern_node_create(pm_parser_t *parser, pm_node_t *value, pm_node_t *target, const pm_token_t *operator) {

*node = (pm_capture_pattern_node_t) {

{

.type = PM_CAPTURE_PATTERN_NODE,

.location = {

.start = value->location.start,

.end = target->location.end

*/

static pm_case_node_t *

pm_case_node_create(pm_parser_t *parser, const pm_token_t *case_keyword, pm_node_t *predicate, const pm_token_t *end_keyword) {

*node = (pm_case_node_t) {

{

.type = PM_CASE_NODE,

.location = {

.start = case_keyword->start,

.end = end_keyword->end

*/

static pm_case_match_node_t *

pm_case_match_node_create(pm_parser_t *parser, const pm_token_t *case_keyword, pm_node_t *predicate, const pm_token_t *end_keyword) {

*node = (pm_case_match_node_t) {

{

.type = PM_CASE_MATCH_NODE,

.location = {

.start = case_keyword->start,

.end = end_keyword->end

*/

static pm_class_node_t *

pm_class_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *class_keyword, pm_node_t *constant_path, const pm_token_t *name, const pm_token_t *inheritance_operator, pm_node_t *superclass, pm_node_t *body, const pm_token_t *end_keyword) {

*node = (pm_class_node_t) {

{

.type = PM_CLASS_NODE,

.location = { .start = class_keyword->start, .end = end_keyword->end },

},

.locals = *locals,

static pm_class_variable_and_write_node_t *

pm_class_variable_and_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);

*node = (pm_class_variable_and_write_node_t) {

{

.type = PM_CLASS_VARIABLE_AND_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

*/

static pm_class_variable_operator_write_node_t *

pm_class_variable_operator_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_class_variable_operator_write_node_t) {

{

.type = PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_class_variable_or_write_node_t *

pm_class_variable_or_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);

*node = (pm_class_variable_or_write_node_t) {

{

.type = PM_CLASS_VARIABLE_OR_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_class_variable_read_node_t *

pm_class_variable_read_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_CLASS_VARIABLE);

*node = (pm_class_variable_read_node_t) {

{

.type = PM_CLASS_VARIABLE_READ_NODE,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.name = pm_parser_constant_id_token(parser, token)

*/

static pm_class_variable_write_node_t *

pm_class_variable_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *read_node, pm_token_t *operator, pm_node_t *value) {

*node = (pm_class_variable_write_node_t) {

{

.type = PM_CLASS_VARIABLE_WRITE_NODE,

.flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),

.location = {

.start = read_node->base.location.start,

.end = value->location.end

static pm_constant_path_and_write_node_t *

pm_constant_path_and_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);

*node = (pm_constant_path_and_write_node_t) {

{

.type = PM_CONSTANT_PATH_AND_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

*/

static pm_constant_path_operator_write_node_t *

pm_constant_path_operator_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_constant_path_operator_write_node_t) {

{

.type = PM_CONSTANT_PATH_OPERATOR_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_constant_path_or_write_node_t *

pm_constant_path_or_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);

*node = (pm_constant_path_or_write_node_t) {

{

.type = PM_CONSTANT_PATH_OR_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_constant_path_node_t *

pm_constant_path_node_create(pm_parser_t *parser, pm_node_t *parent, const pm_token_t *delimiter, const pm_token_t *name_token) {

pm_assert_value_expression(parser, parent);

pm_constant_id_t name = PM_CONSTANT_ID_UNSET;

if (name_token->type == PM_TOKEN_CONSTANT) {

*node = (pm_constant_path_node_t) {

{

.type = PM_CONSTANT_PATH_NODE,

.location = {

.start = parent == NULL ? delimiter->start : parent->location.start,

.end = name_token->end

*/

static pm_constant_path_write_node_t *

pm_constant_path_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_constant_path_write_node_t) {

{

.type = PM_CONSTANT_PATH_WRITE_NODE,

.flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_constant_and_write_node_t *

pm_constant_and_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);

*node = (pm_constant_and_write_node_t) {

{

.type = PM_CONSTANT_AND_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

*/

static pm_constant_operator_write_node_t *

pm_constant_operator_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_constant_operator_write_node_t) {

{

.type = PM_CONSTANT_OPERATOR_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_constant_or_write_node_t *

pm_constant_or_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);

*node = (pm_constant_or_write_node_t) {

{

.type = PM_CONSTANT_OR_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_constant_read_node_t *

pm_constant_read_node_create(pm_parser_t *parser, const pm_token_t *name) {

assert(name->type == PM_TOKEN_CONSTANT || name->type == PM_TOKEN_MISSING);

*node = (pm_constant_read_node_t) {

{

.type = PM_CONSTANT_READ_NODE,

.location = PM_LOCATION_TOKEN_VALUE(name)

},

.name = pm_parser_constant_id_token(parser, name)

*/

static pm_constant_write_node_t *

pm_constant_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_constant_write_node_t) {

{

.type = PM_CONSTANT_WRITE_NODE,

.flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),

.location = {

.start = target->base.location.start,

.end = value->location.end

const pm_token_t *equal,

const pm_token_t *end_keyword

) {

const uint8_t *end;

if (end_keyword->type == PM_TOKEN_NOT_PROVIDED) {

*node = (pm_def_node_t) {

{

.type = PM_DEF_NODE,

.location = { .start = def_keyword->start, .end = end },

},

.name = name,

*/

static pm_defined_node_t *

pm_defined_node_create(pm_parser_t *parser, const pm_token_t *lparen, pm_node_t *value, const pm_token_t *rparen, const pm_location_t *keyword_loc) {

*node = (pm_defined_node_t) {

{

.type = PM_DEFINED_NODE,

.location = {

.start = keyword_loc->start,

.end = (rparen->type == PM_TOKEN_NOT_PROVIDED ? value->location.end : rparen->end)

*/

static pm_else_node_t *

pm_else_node_create(pm_parser_t *parser, const pm_token_t *else_keyword, pm_statements_node_t *statements, const pm_token_t *end_keyword) {

const uint8_t *end = NULL;

if ((end_keyword->type == PM_TOKEN_NOT_PROVIDED) && (statements != NULL)) {

end = statements->base.location.end;

*node = (pm_else_node_t) {

{

.type = PM_ELSE_NODE,

.location = {

.start = else_keyword->start,

.end = end,

*/

static pm_embedded_statements_node_t *

pm_embedded_statements_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {

*node = (pm_embedded_statements_node_t) {

{

.type = PM_EMBEDDED_STATEMENTS_NODE,

.location = {

.start = opening->start,

.end = closing->end

*/

static pm_embedded_variable_node_t *

pm_embedded_variable_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *variable) {

*node = (pm_embedded_variable_node_t) {

{

.type = PM_EMBEDDED_VARIABLE_NODE,

.location = {

.start = operator->start,

.end = variable->location.end

*/

static pm_ensure_node_t *

pm_ensure_node_create(pm_parser_t *parser, const pm_token_t *ensure_keyword, pm_statements_node_t *statements, const pm_token_t *end_keyword) {

*node = (pm_ensure_node_t) {

{

.type = PM_ENSURE_NODE,

.location = {

.start = ensure_keyword->start,

.end = end_keyword->end

static pm_false_node_t *

pm_false_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD_FALSE);

*node = (pm_false_node_t) {{

.type = PM_FALSE_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

}};

*/

static pm_find_pattern_node_t *

pm_find_pattern_node_create(pm_parser_t *parser, pm_node_list_t *nodes) {

pm_node_t *left = nodes->nodes[0];

pm_node_t *right;

*node = (pm_find_pattern_node_t) {

{

.type = PM_FIND_PATTERN_NODE,

.location = {

.start = left->location.start,

.end = right->location.end,

static pm_float_node_t *

pm_float_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_FLOAT);

*node = (pm_float_node_t) {

{

.type = PM_FLOAT_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.value = pm_double_parse(parser, token)

pm_float_node_imaginary_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_FLOAT_IMAGINARY);

*node = (pm_imaginary_node_t) {

{

.type = PM_IMAGINARY_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.numeric = (pm_node_t *) pm_float_node_create(parser, &((pm_token_t) {

pm_float_node_rational_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_FLOAT_RATIONAL);

*node = (pm_rational_node_t) {

{

.type = PM_RATIONAL_NODE,

.flags = PM_INTEGER_BASE_FLAGS_DECIMAL | PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.numerator = { 0 },

pm_float_node_rational_imaginary_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_FLOAT_RATIONAL_IMAGINARY);

*node = (pm_imaginary_node_t) {

{

.type = PM_IMAGINARY_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.numeric = (pm_node_t *) pm_float_node_rational_create(parser, &((pm_token_t) {

const pm_token_t *do_keyword,

const pm_token_t *end_keyword

) {

*node = (pm_for_node_t) {

{

.type = PM_FOR_NODE,

.location = {

.start = for_keyword->start,

.end = end_keyword->end

static pm_forwarding_arguments_node_t *

pm_forwarding_arguments_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_UDOT_DOT_DOT);

return node;

}

static pm_forwarding_parameter_node_t *

pm_forwarding_parameter_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_UDOT_DOT_DOT);

return node;

}

pm_forwarding_super_node_create(pm_parser_t *parser, const pm_token_t *token, pm_arguments_t *arguments) {

assert(arguments->block == NULL || PM_NODE_TYPE_P(arguments->block, PM_BLOCK_NODE));

assert(token->type == PM_TOKEN_KEYWORD_SUPER);

pm_block_node_t *block = NULL;

if (arguments->block != NULL) {

*node = (pm_forwarding_super_node_t) {

{

.type = PM_FORWARDING_SUPER_NODE,

.location = {

.start = token->start,

.end = block != NULL ? block->base.location.end : token->end

*/

static pm_hash_pattern_node_t *

pm_hash_pattern_node_empty_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {

*node = (pm_hash_pattern_node_t) {

{

.type = PM_HASH_PATTERN_NODE,

.location = {

.start = opening->start,

.end = closing->end

*/

static pm_hash_pattern_node_t *

pm_hash_pattern_node_node_list_create(pm_parser_t *parser, pm_node_list_t *elements, pm_node_t *rest) {

const uint8_t *start;

const uint8_t *end;

*node = (pm_hash_pattern_node_t) {

{

.type = PM_HASH_PATTERN_NODE,

.location = {

.start = start,

.end = end

static pm_global_variable_and_write_node_t *

pm_global_variable_and_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);

*node = (pm_global_variable_and_write_node_t) {

{

.type = PM_GLOBAL_VARIABLE_AND_WRITE_NODE,

.location = {

.start = target->location.start,

.end = value->location.end

*/

static pm_global_variable_operator_write_node_t *

pm_global_variable_operator_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_global_variable_operator_write_node_t) {

{

.type = PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE,

.location = {

.start = target->location.start,

.end = value->location.end

static pm_global_variable_or_write_node_t *

pm_global_variable_or_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);

*node = (pm_global_variable_or_write_node_t) {

{

.type = PM_GLOBAL_VARIABLE_OR_WRITE_NODE,

.location = {

.start = target->location.start,

.end = value->location.end

*/

static pm_global_variable_read_node_t *

pm_global_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name) {

*node = (pm_global_variable_read_node_t) {

{

.type = PM_GLOBAL_VARIABLE_READ_NODE,

.location = PM_LOCATION_TOKEN_VALUE(name),

},

.name = pm_parser_constant_id_token(parser, name)

*/

static pm_global_variable_read_node_t *

pm_global_variable_read_node_synthesized_create(pm_parser_t *parser, pm_constant_id_t name) {

*node = (pm_global_variable_read_node_t) {

{

.type = PM_GLOBAL_VARIABLE_READ_NODE,

.location = PM_LOCATION_NULL_VALUE(parser)

},

.name = name

*/

static pm_global_variable_write_node_t *

pm_global_variable_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_global_variable_write_node_t) {

{

.type = PM_GLOBAL_VARIABLE_WRITE_NODE,

.flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),

.location = {

.start = target->location.start,

*/

static pm_global_variable_write_node_t *

pm_global_variable_write_node_synthesized_create(pm_parser_t *parser, pm_constant_id_t name, pm_node_t *value) {

*node = (pm_global_variable_write_node_t) {

{

.type = PM_GLOBAL_VARIABLE_WRITE_NODE,

.location = PM_LOCATION_NULL_VALUE(parser)

},

.name = name,

static pm_hash_node_t *

pm_hash_node_create(pm_parser_t *parser, const pm_token_t *opening) {

assert(opening != NULL);

*node = (pm_hash_node_t) {

{

.type = PM_HASH_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(opening)

},

.opening_loc = PM_LOCATION_TOKEN_VALUE(opening),

const pm_token_t *end_keyword

) {

pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

const uint8_t *end;

if (end_keyword->type != PM_TOKEN_NOT_PROVIDED) {

{

.type = PM_IF_NODE,

.flags = PM_NODE_FLAG_NEWLINE,

.location = {

.start = if_keyword->start,

.end = end

static pm_if_node_t *

pm_if_node_modifier_create(pm_parser_t *parser, pm_node_t *statement, const pm_token_t *if_keyword, pm_node_t *predicate) {

pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

pm_statements_node_t *statements = pm_statements_node_create(parser);

pm_statements_node_body_append(parser, statements, statement);

{

.type = PM_IF_NODE,

.flags = PM_NODE_FLAG_NEWLINE,

.location = {

.start = statement->location.start,

.end = predicate->location.end

pm_token_t end_keyword = not_provided(parser);

pm_else_node_t *else_node = pm_else_node_create(parser, colon, else_statements, &end_keyword);

*node = (pm_if_node_t) {

{

.type = PM_IF_NODE,

.flags = PM_NODE_FLAG_NEWLINE,

.location = {

.start = predicate->location.start,

.end = false_expression->location.end,

*/

static pm_implicit_node_t *

pm_implicit_node_create(pm_parser_t *parser, pm_node_t *value) {

*node = (pm_implicit_node_t) {

{

.type = PM_IMPLICIT_NODE,

.location = value->location

},

.value = value

pm_implicit_rest_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_COMMA);

*node = (pm_implicit_rest_node_t) {

{

.type = PM_IMPLICIT_REST_NODE,

.location = PM_LOCATION_TOKEN_VALUE(token)

}

};

static pm_integer_node_t *

pm_integer_node_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {

assert(token->type == PM_TOKEN_INTEGER);

*node = (pm_integer_node_t) {

{

.type = PM_INTEGER_NODE,

.flags = base | PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.value = { 0 }

pm_integer_node_imaginary_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {

assert(token->type == PM_TOKEN_INTEGER_IMAGINARY);

*node = (pm_imaginary_node_t) {

{

.type = PM_IMAGINARY_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.numeric = (pm_node_t *) pm_integer_node_create(parser, base, &((pm_token_t) {

pm_integer_node_rational_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {

assert(token->type == PM_TOKEN_INTEGER_RATIONAL);

*node = (pm_rational_node_t) {

{

.type = PM_RATIONAL_NODE,

.flags = base | PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.numerator = { 0 },

pm_integer_node_rational_imaginary_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {

assert(token->type == PM_TOKEN_INTEGER_RATIONAL_IMAGINARY);

*node = (pm_imaginary_node_t) {

{

.type = PM_IMAGINARY_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.numeric = (pm_node_t *) pm_integer_node_rational_create(parser, base, &((pm_token_t) {

*/

static pm_in_node_t *

pm_in_node_create(pm_parser_t *parser, pm_node_t *pattern, pm_statements_node_t *statements, const pm_token_t *in_keyword, const pm_token_t *then_keyword) {

const uint8_t *end;

if (statements != NULL) {

*node = (pm_in_node_t) {

{

.type = PM_IN_NODE,

.location = {

.start = in_keyword->start,

.end = end

static pm_instance_variable_and_write_node_t *

pm_instance_variable_and_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);

*node = (pm_instance_variable_and_write_node_t) {

{

.type = PM_INSTANCE_VARIABLE_AND_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

*/

static pm_instance_variable_operator_write_node_t *

pm_instance_variable_operator_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_instance_variable_operator_write_node_t) {

{

.type = PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_instance_variable_or_write_node_t *

pm_instance_variable_or_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {

assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);

*node = (pm_instance_variable_or_write_node_t) {

{

.type = PM_INSTANCE_VARIABLE_OR_WRITE_NODE,

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_instance_variable_read_node_t *

pm_instance_variable_read_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_INSTANCE_VARIABLE);

*node = (pm_instance_variable_read_node_t) {

{

.type = PM_INSTANCE_VARIABLE_READ_NODE,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.name = pm_parser_constant_id_token(parser, token)

*/

static pm_instance_variable_write_node_t *

pm_instance_variable_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *read_node, pm_token_t *operator, pm_node_t *value) {

*node = (pm_instance_variable_write_node_t) {

{

.type = PM_INSTANCE_VARIABLE_WRITE_NODE,

.flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),

.location = {

.start = read_node->base.location.start,

.end = value->location.end

*/

static pm_interpolated_regular_expression_node_t *

pm_interpolated_regular_expression_node_create(pm_parser_t *parser, const pm_token_t *opening) {

*node = (pm_interpolated_regular_expression_node_t) {

{

.type = PM_INTERPOLATED_REGULAR_EXPRESSION_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = {

.start = opening->start,

.end = NULL,

*/

static pm_interpolated_string_node_t *

pm_interpolated_string_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_node_list_t *parts, const pm_token_t *closing) {

pm_node_flags_t flags = PM_NODE_FLAG_STATIC_LITERAL;

switch (parser->frozen_string_literal) {

{

.type = PM_INTERPOLATED_STRING_NODE,

.flags = flags,

.location = {

.start = opening->start,

.end = closing->end,

*/

static pm_interpolated_symbol_node_t *

pm_interpolated_symbol_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_node_list_t *parts, const pm_token_t *closing) {

*node = (pm_interpolated_symbol_node_t) {

{

.type = PM_INTERPOLATED_SYMBOL_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = {

.start = opening->start,

.end = closing->end,

*/

static pm_interpolated_x_string_node_t *

pm_interpolated_xstring_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {

*node = (pm_interpolated_x_string_node_t) {

{

.type = PM_INTERPOLATED_X_STRING_NODE,

.location = {

.start = opening->start,

.end = closing->end

*/

static pm_it_local_variable_read_node_t *

pm_it_local_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name) {

*node = (pm_it_local_variable_read_node_t) {

{

.type = PM_IT_LOCAL_VARIABLE_READ_NODE,

.location = PM_LOCATION_TOKEN_VALUE(name)

}

};

*/

static pm_it_parameters_node_t *

pm_it_parameters_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {

*node = (pm_it_parameters_node_t) {

{

.type = PM_IT_PARAMETERS_NODE,

.location = {

.start = opening->start,

.end = closing->end

*/

static pm_keyword_hash_node_t *

pm_keyword_hash_node_create(pm_parser_t *parser) {

*node = (pm_keyword_hash_node_t) {

.base = {

.type = PM_KEYWORD_HASH_NODE,

},

.elements = { 0 }

};

*/

static pm_required_keyword_parameter_node_t *

pm_required_keyword_parameter_node_create(pm_parser_t *parser, const pm_token_t *name) {

*node = (pm_required_keyword_parameter_node_t) {

{

.type = PM_REQUIRED_KEYWORD_PARAMETER_NODE,

.location = {

.start = name->start,

.end = name->end

*/

static pm_optional_keyword_parameter_node_t *

pm_optional_keyword_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, pm_node_t *value) {

*node = (pm_optional_keyword_parameter_node_t) {

{

.type = PM_OPTIONAL_KEYWORD_PARAMETER_NODE,

.location = {

.start = name->start,

.end = value->location.end

*/

static pm_keyword_rest_parameter_node_t *

pm_keyword_rest_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *name) {

*node = (pm_keyword_rest_parameter_node_t) {

{

.type = PM_KEYWORD_REST_PARAMETER_NODE,

.location = {

.start = operator->start,

.end = (name->type == PM_TOKEN_NOT_PROVIDED ? operator->end : name->end)

pm_node_t *parameters,

pm_node_t *body

) {

*node = (pm_lambda_node_t) {

{

.type = PM_LAMBDA_NODE,

.location = {

.start = operator->start,

.end = closing->end

pm_local_variable_and_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {

assert(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_CALL_NODE));

assert(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);

*node = (pm_local_variable_and_write_node_t) {

{

.type = PM_LOCAL_VARIABLE_AND_WRITE_NODE,

.location = {

.start = target->location.start,

.end = value->location.end

*/

static pm_local_variable_operator_write_node_t *

pm_local_variable_operator_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {

*node = (pm_local_variable_operator_write_node_t) {

{

.type = PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE,

.location = {

.start = target->location.start,

.end = value->location.end

pm_local_variable_or_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {

assert(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_CALL_NODE));

assert(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);

*node = (pm_local_variable_or_write_node_t) {

{

.type = PM_LOCAL_VARIABLE_OR_WRITE_NODE,

.location = {

.start = target->location.start,

.end = value->location.end

pm_local_variable_read_node_create_constant_id(pm_parser_t *parser, const pm_token_t *name, pm_constant_id_t name_id, uint32_t depth, bool missing) {

if (!missing) pm_locals_read(&pm_parser_scope_find(parser, depth)->locals, name_id);

*node = (pm_local_variable_read_node_t) {

{

.type = PM_LOCAL_VARIABLE_READ_NODE,

.location = PM_LOCATION_TOKEN_VALUE(name)

},

.name = name_id,

*/

static pm_local_variable_write_node_t *

pm_local_variable_write_node_create(pm_parser_t *parser, pm_constant_id_t name, uint32_t depth, pm_node_t *value, const pm_location_t *name_loc, const pm_token_t *operator) {

*node = (pm_local_variable_write_node_t) {

{

.type = PM_LOCAL_VARIABLE_WRITE_NODE,

.flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),

.location = {

.start = name_loc->start,

.end = value->location.end

static pm_local_variable_target_node_t *

pm_local_variable_target_node_create(pm_parser_t *parser, const pm_location_t *location, pm_constant_id_t name, uint32_t depth) {

pm_refute_numbered_parameter(parser, location->start, location->end);

*node = (pm_local_variable_target_node_t) {

{

.type = PM_LOCAL_VARIABLE_TARGET_NODE,

.location = *location

},

.name = name,

pm_match_predicate_node_create(pm_parser_t *parser, pm_node_t *value, pm_node_t *pattern, const pm_token_t *operator) {

pm_assert_value_expression(parser, value);

*node = (pm_match_predicate_node_t) {

{

.type = PM_MATCH_PREDICATE_NODE,

.location = {

.start = value->location.start,

.end = pattern->location.end

pm_match_required_node_create(pm_parser_t *parser, pm_node_t *value, pm_node_t *pattern, const pm_token_t *operator) {

pm_assert_value_expression(parser, value);

*node = (pm_match_required_node_t) {

{

.type = PM_MATCH_REQUIRED_NODE,

.location = {

.start = value->location.start,

.end = pattern->location.end

*/

static pm_match_write_node_t *

pm_match_write_node_create(pm_parser_t *parser, pm_call_node_t *call) {

*node = (pm_match_write_node_t) {

{

.type = PM_MATCH_WRITE_NODE,

.location = call->base.location

},

.call = call,

*/

static pm_module_node_t *

pm_module_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *module_keyword, pm_node_t *constant_path, const pm_token_t *name, pm_node_t *body, const pm_token_t *end_keyword) {

*node = (pm_module_node_t) {

{

.type = PM_MODULE_NODE,

.location = {

.start = module_keyword->start,

.end = end_keyword->end

*/

static pm_multi_target_node_t *

pm_multi_target_node_create(pm_parser_t *parser) {

*node = (pm_multi_target_node_t) {

{

.type = PM_MULTI_TARGET_NODE,

.location = { .start = NULL, .end = NULL }

},

.lefts = { 0 },

*/

static pm_multi_write_node_t *

pm_multi_write_node_create(pm_parser_t *parser, pm_multi_target_node_t *target, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_multi_write_node_t) {

{

.type = PM_MULTI_WRITE_NODE,

.flags = pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),

.location = {

.start = target->base.location.start,

.end = value->location.end

static pm_next_node_t *

pm_next_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {

assert(keyword->type == PM_TOKEN_KEYWORD_NEXT);

*node = (pm_next_node_t) {

{

.type = PM_NEXT_NODE,

.location = {

.start = keyword->start,

.end = (arguments == NULL ? keyword->end : arguments->base.location.end)

static pm_nil_node_t *

pm_nil_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD_NIL);

*node = (pm_nil_node_t) {{

.type = PM_NIL_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

}};

pm_no_keywords_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *keyword) {

assert(operator->type == PM_TOKEN_USTAR_STAR || operator->type == PM_TOKEN_STAR_STAR);

assert(keyword->type == PM_TOKEN_KEYWORD_NIL);

*node = (pm_no_keywords_parameter_node_t) {

{

.type = PM_NO_KEYWORDS_PARAMETER_NODE,

.location = {

.start = operator->start,

.end = keyword->end

*/

static pm_numbered_parameters_node_t *

pm_numbered_parameters_node_create(pm_parser_t *parser, const pm_location_t *location, uint8_t maximum) {

*node = (pm_numbered_parameters_node_t) {

{

.type = PM_NUMBERED_PARAMETERS_NODE,

.location = *location

},

.maximum = maximum

static pm_numbered_reference_read_node_t *

pm_numbered_reference_read_node_create(pm_parser_t *parser, const pm_token_t *name) {

assert(name->type == PM_TOKEN_NUMBERED_REFERENCE);

*node = (pm_numbered_reference_read_node_t) {

{

.type = PM_NUMBERED_REFERENCE_READ_NODE,

.location = PM_LOCATION_TOKEN_VALUE(name),

},

.number = pm_numbered_reference_read_node_number(parser, name)

*/

static pm_optional_parameter_node_t *

pm_optional_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, const pm_token_t *operator, pm_node_t *value) {

*node = (pm_optional_parameter_node_t) {

{

.type = PM_OPTIONAL_PARAMETER_NODE,

.location = {

.start = name->start,

.end = value->location.end

pm_or_node_create(pm_parser_t *parser, pm_node_t *left, const pm_token_t *operator, pm_node_t *right) {

pm_assert_value_expression(parser, left);

*node = (pm_or_node_t) {

{

.type = PM_OR_NODE,

.location = {

.start = left->location.start,

.end = right->location.end

*/

static pm_parameters_node_t *

pm_parameters_node_create(pm_parser_t *parser) {

*node = (pm_parameters_node_t) {

{

.type = PM_PARAMETERS_NODE,

.location = PM_LOCATION_TOKEN_VALUE(&parser->current)

},

.rest = NULL,

*/

static pm_program_node_t *

pm_program_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, pm_statements_node_t *statements) {

*node = (pm_program_node_t) {

{

.type = PM_PROGRAM_NODE,

.location = {

.start = statements == NULL ? parser->start : statements->base.location.start,

.end = statements == NULL ? parser->end : statements->base.location.end

*/

static pm_parentheses_node_t *

pm_parentheses_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_node_t *body, const pm_token_t *closing) {

*node = (pm_parentheses_node_t) {

{

.type = PM_PARENTHESES_NODE,

.location = {

.start = opening->start,

.end = closing->end

*/

static pm_pinned_expression_node_t *

pm_pinned_expression_node_create(pm_parser_t *parser, pm_node_t *expression, const pm_token_t *operator, const pm_token_t *lparen, const pm_token_t *rparen) {

*node = (pm_pinned_expression_node_t) {

{

.type = PM_PINNED_EXPRESSION_NODE,

.location = {

.start = operator->start,

.end = rparen->end

*/

static pm_pinned_variable_node_t *

pm_pinned_variable_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *variable) {

*node = (pm_pinned_variable_node_t) {

{

.type = PM_PINNED_VARIABLE_NODE,

.location = {

.start = operator->start,

.end = variable->location.end

*/

static pm_post_execution_node_t *

pm_post_execution_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {

*node = (pm_post_execution_node_t) {

{

.type = PM_POST_EXECUTION_NODE,

.location = {

.start = keyword->start,

.end = closing->end

*/

static pm_pre_execution_node_t *

pm_pre_execution_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {

*node = (pm_pre_execution_node_t) {

{

.type = PM_PRE_EXECUTION_NODE,

.location = {

.start = keyword->start,

.end = closing->end

pm_assert_value_expression(parser, left);

pm_assert_value_expression(parser, right);

pm_node_flags_t flags = 0;

// Indicate that this node is an exclusive range if the operator is `...`.

{

.type = PM_RANGE_NODE,

.flags = flags,

.location = {

.start = (left == NULL ? operator->start : left->location.start),

.end = (right == NULL ? operator->end : right->location.end)

static pm_redo_node_t *

pm_redo_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD_REDO);

return node;

}

*/

static pm_regular_expression_node_t *

pm_regular_expression_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *unescaped) {

*node = (pm_regular_expression_node_t) {

{

.type = PM_REGULAR_EXPRESSION_NODE,

.flags = pm_regular_expression_flags_create(parser, closing) | PM_NODE_FLAG_STATIC_LITERAL,

.location = {

.start = MIN(opening->start, closing->start),

.end = MAX(opening->end, closing->end)

*/

static pm_required_parameter_node_t *

pm_required_parameter_node_create(pm_parser_t *parser, const pm_token_t *token) {

*node = (pm_required_parameter_node_t) {

{

.type = PM_REQUIRED_PARAMETER_NODE,

.location = PM_LOCATION_TOKEN_VALUE(token)

},

.name = pm_parser_constant_id_token(parser, token)

*/

static pm_rescue_modifier_node_t *

pm_rescue_modifier_node_create(pm_parser_t *parser, pm_node_t *expression, const pm_token_t *keyword, pm_node_t *rescue_expression) {

*node = (pm_rescue_modifier_node_t) {

{

.type = PM_RESCUE_MODIFIER_NODE,

.location = {

.start = expression->location.start,

.end = rescue_expression->location.end

*/

static pm_rescue_node_t *

pm_rescue_node_create(pm_parser_t *parser, const pm_token_t *keyword) {

*node = (pm_rescue_node_t) {

{

.type = PM_RESCUE_NODE,

.location = PM_LOCATION_TOKEN_VALUE(keyword)

},

.keyword_loc = PM_LOCATION_TOKEN_VALUE(keyword),

*/

static pm_rest_parameter_node_t *

pm_rest_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *name) {

*node = (pm_rest_parameter_node_t) {

{

.type = PM_REST_PARAMETER_NODE,

.location = {

.start = operator->start,

.end = (name->type == PM_TOKEN_NOT_PROVIDED ? operator->end : name->end)

static pm_retry_node_t *

pm_retry_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD_RETRY);

return node;

}

*/

static pm_return_node_t *

pm_return_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {

*node = (pm_return_node_t) {

{

.type = PM_RETURN_NODE,

.location = {

.start = keyword->start,

.end = (arguments == NULL ? keyword->end : arguments->base.location.end)

static pm_self_node_t *

pm_self_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD_SELF);

*node = (pm_self_node_t) {{

.type = PM_SELF_NODE,

.location = PM_LOCATION_TOKEN_VALUE(token)

}};

*/

static pm_shareable_constant_node_t *

pm_shareable_constant_node_create(pm_parser_t *parser, pm_node_t *write, pm_shareable_constant_value_t value) {

*node = (pm_shareable_constant_node_t) {

{

.type = PM_SHAREABLE_CONSTANT_NODE,

.flags = (pm_node_flags_t) value,

.location = PM_LOCATION_NODE_VALUE(write)

},

.write = write

*/

static pm_singleton_class_node_t *

pm_singleton_class_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *class_keyword, const pm_token_t *operator, pm_node_t *expression, pm_node_t *body, const pm_token_t *end_keyword) {

*node = (pm_singleton_class_node_t) {

{

.type = PM_SINGLETON_CLASS_NODE,

.location = {

.start = class_keyword->start,

.end = end_keyword->end

static pm_source_encoding_node_t *

pm_source_encoding_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD___ENCODING__);

*node = (pm_source_encoding_node_t) {{

.type = PM_SOURCE_ENCODING_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

}};

*/

static pm_source_file_node_t*

pm_source_file_node_create(pm_parser_t *parser, const pm_token_t *file_keyword) {

assert(file_keyword->type == PM_TOKEN_KEYWORD___FILE__);

pm_node_flags_t flags = 0;

{

.type = PM_SOURCE_FILE_NODE,

.flags = flags,

.location = PM_LOCATION_TOKEN_VALUE(file_keyword),

},

.filepath = parser->filepath

static pm_source_line_node_t *

pm_source_line_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD___LINE__);

*node = (pm_source_line_node_t) {{

.type = PM_SOURCE_LINE_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

}};

*/

static pm_splat_node_t *

pm_splat_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *expression) {

*node = (pm_splat_node_t) {

{

.type = PM_SPLAT_NODE,

.location = {

.start = operator->start,

.end = (expression == NULL ? operator->end : expression->location.end)

*/

static pm_statements_node_t *

pm_statements_node_create(pm_parser_t *parser) {

*node = (pm_statements_node_t) {

{

.type = PM_STATEMENTS_NODE,

.location = PM_LOCATION_NULL_VALUE(parser)

},

.body = { 0 }

*/

static inline pm_string_node_t *

pm_string_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *string) {

pm_node_flags_t flags = 0;

switch (parser->frozen_string_literal) {

{

.type = PM_STRING_NODE,

.flags = flags,

.location = {

.start = (opening->type == PM_TOKEN_NOT_PROVIDED ? content->start : opening->start),

.end = (closing->type == PM_TOKEN_NOT_PROVIDED ? content->end : closing->end)

static pm_super_node_t *

pm_super_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_t *arguments) {

assert(keyword->type == PM_TOKEN_KEYWORD_SUPER);

const uint8_t *end = pm_arguments_end(arguments);

if (end == NULL) {

*node = (pm_super_node_t) {

{

.type = PM_SUPER_NODE,

.location = {

.start = keyword->start,

.end = end,

*/

static pm_symbol_node_t *

pm_symbol_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *value, const pm_token_t *closing, const pm_string_t *unescaped, pm_node_flags_t flags) {

*node = (pm_symbol_node_t) {

{

.type = PM_SYMBOL_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL | flags,

.location = {

.start = (opening->type == PM_TOKEN_NOT_PROVIDED ? value->start : opening->start),

.end = (closing->type == PM_TOKEN_NOT_PROVIDED ? value->end : closing->end)

*/

static pm_symbol_node_t *

pm_symbol_node_synthesized_create(pm_parser_t *parser, const char *content) {

*node = (pm_symbol_node_t) {

{

.type = PM_SYMBOL_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL | PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING,

.location = PM_LOCATION_NULL_VALUE(parser)

},

.value_loc = PM_LOCATION_NULL_VALUE(parser),

*/

static pm_symbol_node_t *

pm_string_node_to_symbol_node(pm_parser_t *parser, pm_string_node_t *node, const pm_token_t *opening, const pm_token_t *closing) {

*new_node = (pm_symbol_node_t) {

{

.type = PM_SYMBOL_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = {

.start = opening->start,

.end = closing->end

*/

static pm_string_node_t *

pm_symbol_node_to_string_node(pm_parser_t *parser, pm_symbol_node_t *node) {

pm_node_flags_t flags = 0;

switch (parser->frozen_string_literal) {

{

.type = PM_STRING_NODE,

.flags = flags,

.location = node->base.location

},

.opening_loc = node->opening_loc,

static pm_true_node_t *

pm_true_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD_TRUE);

*node = (pm_true_node_t) {{

.type = PM_TRUE_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = PM_LOCATION_TOKEN_VALUE(token)

}};

*/

static pm_true_node_t *

pm_true_node_synthesized_create(pm_parser_t *parser) {

*node = (pm_true_node_t) {{

.type = PM_TRUE_NODE,

.flags = PM_NODE_FLAG_STATIC_LITERAL,

.location = { .start = parser->start, .end = parser->end }

}};

static pm_undef_node_t *

pm_undef_node_create(pm_parser_t *parser, const pm_token_t *token) {

assert(token->type == PM_TOKEN_KEYWORD_UNDEF);

*node = (pm_undef_node_t) {

{

.type = PM_UNDEF_NODE,

.location = PM_LOCATION_TOKEN_VALUE(token),

},

.keyword_loc = PM_LOCATION_TOKEN_VALUE(token),

static pm_unless_node_t *

pm_unless_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, const pm_token_t *then_keyword, pm_statements_node_t *statements) {

pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

const uint8_t *end;

if (statements != NULL) {

{

.type = PM_UNLESS_NODE,

.flags = PM_NODE_FLAG_NEWLINE,

.location = {

.start = keyword->start,

.end = end

static pm_unless_node_t *

pm_unless_node_modifier_create(pm_parser_t *parser, pm_node_t *statement, const pm_token_t *unless_keyword, pm_node_t *predicate) {

pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

pm_statements_node_t *statements = pm_statements_node_create(parser);

pm_statements_node_body_append(parser, statements, statement);

{

.type = PM_UNLESS_NODE,

.flags = PM_NODE_FLAG_NEWLINE,

.location = {

.start = statement->location.start,

.end = predicate->location.end

*/

static pm_until_node_t *

pm_until_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *closing, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {

pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

*node = (pm_until_node_t) {

{

.type = PM_UNTIL_NODE,

.flags = flags,

.location = {

.start = keyword->start,

.end = closing->end,

*/

static pm_until_node_t *

pm_until_node_modifier_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {

pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

pm_loop_modifier_block_exits(parser, statements);

{

.type = PM_UNTIL_NODE,

.flags = flags,

.location = {

.start = statements->base.location.start,

.end = predicate->location.end,

*/

static pm_when_node_t *

pm_when_node_create(pm_parser_t *parser, const pm_token_t *keyword) {

*node = (pm_when_node_t) {

{

.type = PM_WHEN_NODE,

.location = {

.start = keyword->start,

.end = NULL

*/

static pm_while_node_t *

pm_while_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *closing, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {

pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

*node = (pm_while_node_t) {

{

.type = PM_WHILE_NODE,

.flags = flags,

.location = {

.start = keyword->start,

.end = closing->end

*/

static pm_while_node_t *

pm_while_node_modifier_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {

pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);

pm_loop_modifier_block_exits(parser, statements);

{

.type = PM_WHILE_NODE,

.flags = flags,

.location = {

.start = statements->base.location.start,

.end = predicate->location.end

*/

static pm_while_node_t *

pm_while_node_synthesized_create(pm_parser_t *parser, pm_node_t *predicate, pm_statements_node_t *statements) {

*node = (pm_while_node_t) {

{

.type = PM_WHILE_NODE,

.location = PM_LOCATION_NULL_VALUE(parser)

},

.keyword_loc = PM_LOCATION_NULL_VALUE(parser),

*/

static pm_x_string_node_t *

pm_xstring_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *unescaped) {

*node = (pm_x_string_node_t) {

{

.type = PM_X_STRING_NODE,

.flags = PM_STRING_FLAGS_FROZEN,

.location = {

.start = opening->start,

.end = closing->end

*/

static pm_yield_node_t *

pm_yield_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_location_t *lparen_loc, pm_arguments_node_t *arguments, const pm_location_t *rparen_loc) {

const uint8_t *end;

if (rparen_loc->start != NULL) {

*node = (pm_yield_node_t) {

{

.type = PM_YIELD_NODE,

.location = {

.start = keyword->start,

.end = end

return node;

}

/**

* Check if any of the currently visible scopes contain a local variable

assert(source != NULL);

*parser = (pm_parser_t) {

.lex_state = PM_LEX_STATE_BEG,

.enclosure_nesting = 0,

.lambda_enclosure_nesting = -1,

<%- if node.fields.any? { |field| ![Prism::Template::NodeField, Prism::Template::OptionalNodeField].include?(field.class) } -%>

pm_<%= node.human %>_t *cast = (pm_<%= node.human %>_t *) node;

<%- end -%>

// source

argv[0] = source;

// location

// flags

// <%= field.name %>

<%- case field -%>

<%- end -%>

<%- end -%>

break;

}

<%- end -%>

pm_node_flags_t flags;

/**

* This is the location of the node in the source. It's a range of bytes

* containing a start and an end.

*/

#

# Prism::ArrayNode.new(

# source,

# Prism::Location.new(source, 0, 3),

# 0,

# [

# Prism::IntegerNode.new(

# source,

# Prism::Location.new(source, 1, 1),

# Prism::IntegerBaseFlags::DECIMAL,

# 1

<%- nodes.each do |node| -%>

# Create a new <%= node.name %> node.

case field

when Prism::Template::NodeField, Prism::Template::ConstantField

"#{field.name}: default_node(source, location)"

raise

end

}].join(", ") %>)

end

<%- end -%>

<%- flags.each do |flag| -%>

attr_reader :source

private :source

# A Location instance that represents the location of this node in the

# source.

def location

<%- end -%>

class <%= node.name -%> < Node

# Initialize a new <%= node.name %> node.

@source = source

@location = location

@flags = flags

<%- node.fields.each do |field| -%>

}.compact.join(", ") %>] #: Array[Prism::node | Location]

end

end

# def deconstruct: () -> Array[nil | Node]

alias deconstruct child_nodes

def deconstruct_keys(keys)

end

<%- if (node_flags = node.flags) -%>

<%- node_flags.values.each do |value| -%>

if RUBY_ENGINE == "ruby"

def load_node

type = io.getbyte

location = load_location

case type

<%- if node.needs_serialized_length? -%>

load_uint32

<%- end -%>

case field

when Prism::Template::NodeField then "load_node"

when Prism::Template::OptionalNodeField then "load_optional_node"

nil,

<%- nodes.each do |node| -%>

-> {

location = load_location

<%- if node.needs_serialized_length? -%>

load_uint32

<%- end -%>

case field

when Prism::Template::NodeField then "load_node"

when Prism::Template::OptionalNodeField then "load_optional_node"

size_t offset = buffer->length;

pm_serialize_location(parser, &node->location, buffer);

switch (PM_NODE_TYPE(node)) {