herb 0.10.4-x86-linux-gnu → 0.11.1-x86-linux-gnu

data/src/ast/ast_nodes.c

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /home/runner/work/herb/herb/templates/src/ast/ast_nodes.c.erb
+// be modified manually. See templates/src/ast/ast_nodes.c.erb
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -50,9 +50,9 @@ AST_HTML_OPEN_TAG_NODE_T* ast_html_open_tag_node_init(token_T* tag_opening, toke
 
   ast_node_init(&html_open_tag_node->base, AST_HTML_OPEN_TAG_NODE, start_position, end_position, errors, allocator);
 
-  html_open_tag_node->tag_opening = token_copy(tag_opening, allocator);
-  html_open_tag_node->tag_name = token_copy(tag_name, allocator);
-  html_open_tag_node->tag_closing = token_copy(tag_closing, allocator);
+  html_open_tag_node->tag_opening = tag_opening;
+  html_open_tag_node->tag_name = tag_name;
+  html_open_tag_node->tag_closing = tag_closing;
   html_open_tag_node->children = children;
   html_open_tag_node->is_void = is_void;
 
@@ -67,7 +67,7 @@ AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T* ast_html_conditional_open_tag_node_init(AS
   ast_node_init(&html_conditional_open_tag_node->base, AST_HTML_CONDITIONAL_OPEN_TAG_NODE, start_position, end_position, errors, allocator);
 
   html_conditional_open_tag_node->conditional = conditional;
-  html_conditional_open_tag_node->tag_name = token_copy(tag_name, allocator);
+  html_conditional_open_tag_node->tag_name = tag_name;
   html_conditional_open_tag_node->is_void = is_void;
 
   return html_conditional_open_tag_node;
@@ -80,10 +80,10 @@ AST_HTML_CLOSE_TAG_NODE_T* ast_html_close_tag_node_init(token_T* tag_opening, to
 
   ast_node_init(&html_close_tag_node->base, AST_HTML_CLOSE_TAG_NODE, start_position, end_position, errors, allocator);
 
-  html_close_tag_node->tag_opening = token_copy(tag_opening, allocator);
-  html_close_tag_node->tag_name = token_copy(tag_name, allocator);
+  html_close_tag_node->tag_opening = tag_opening;
+  html_close_tag_node->tag_name = tag_name;
   html_close_tag_node->children = children;
-  html_close_tag_node->tag_closing = token_copy(tag_closing, allocator);
+  html_close_tag_node->tag_closing = tag_closing;
 
   return html_close_tag_node;
 }
@@ -95,7 +95,7 @@ AST_HTML_OMITTED_CLOSE_TAG_NODE_T* ast_html_omitted_close_tag_node_init(token_T*
 
   ast_node_init(&html_omitted_close_tag_node->base, AST_HTML_OMITTED_CLOSE_TAG_NODE, start_position, end_position, errors, allocator);
 
-  html_omitted_close_tag_node->tag_name = token_copy(tag_name, allocator);
+  html_omitted_close_tag_node->tag_name = tag_name;
 
   return html_omitted_close_tag_node;
 }
@@ -107,7 +107,7 @@ AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T* ast_html_virtual_close_tag_node_init(token_T*
 
   ast_node_init(&html_virtual_close_tag_node->base, AST_HTML_VIRTUAL_CLOSE_TAG_NODE, start_position, end_position, errors, allocator);
 
-  html_virtual_close_tag_node->tag_name = token_copy(tag_name, allocator);
+  html_virtual_close_tag_node->tag_name = tag_name;
 
   return html_virtual_close_tag_node;
 }
@@ -120,7 +120,7 @@ AST_HTML_ELEMENT_NODE_T* ast_html_element_node_init(AST_NODE_T* open_tag, token_
   ast_node_init(&html_element_node->base, AST_HTML_ELEMENT_NODE, start_position, end_position, errors, allocator);
 
   html_element_node->open_tag = open_tag;
-  html_element_node->tag_name = token_copy(tag_name, allocator);
+  html_element_node->tag_name = tag_name;
   html_element_node->body = body;
   html_element_node->close_tag = close_tag;
   html_element_node->is_void = is_void;
@@ -142,7 +142,7 @@ AST_HTML_CONDITIONAL_ELEMENT_NODE_T* ast_html_conditional_element_node_init(hb_s
   html_conditional_element_node->body = body;
   html_conditional_element_node->close_tag = close_tag;
   html_conditional_element_node->close_conditional = close_conditional;
-  html_conditional_element_node->tag_name = token_copy(tag_name, allocator);
+  html_conditional_element_node->tag_name = tag_name;
   html_conditional_element_node->element_source = element_source;
 
   return html_conditional_element_node;
@@ -155,9 +155,9 @@ AST_HTML_ATTRIBUTE_VALUE_NODE_T* ast_html_attribute_value_node_init(token_T* ope
 
   ast_node_init(&html_attribute_value_node->base, AST_HTML_ATTRIBUTE_VALUE_NODE, start_position, end_position, errors, allocator);
 
-  html_attribute_value_node->open_quote = token_copy(open_quote, allocator);
+  html_attribute_value_node->open_quote = open_quote;
   html_attribute_value_node->children = children;
-  html_attribute_value_node->close_quote = token_copy(close_quote, allocator);
+  html_attribute_value_node->close_quote = close_quote;
   html_attribute_value_node->quoted = quoted;
 
   return html_attribute_value_node;
@@ -183,7 +183,7 @@ AST_HTML_ATTRIBUTE_NODE_T* ast_html_attribute_node_init(struct AST_HTML_ATTRIBUT
   ast_node_init(&html_attribute_node->base, AST_HTML_ATTRIBUTE_NODE, start_position, end_position, errors, allocator);
 
   html_attribute_node->name = name;
-  html_attribute_node->equals = token_copy(equals, allocator);
+  html_attribute_node->equals = equals;
   html_attribute_node->value = value;
 
   return html_attribute_node;
@@ -221,10 +221,10 @@ AST_ERB_OPEN_TAG_NODE_T* ast_erb_open_tag_node_init(token_T* tag_opening, token_
 
   ast_node_init(&erb_open_tag_node->base, AST_ERB_OPEN_TAG_NODE, start_position, end_position, errors, allocator);
 
-  erb_open_tag_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_open_tag_node->content = token_copy(content, allocator);
-  erb_open_tag_node->tag_closing = token_copy(tag_closing, allocator);
-  erb_open_tag_node->tag_name = token_copy(tag_name, allocator);
+  erb_open_tag_node->tag_opening = tag_opening;
+  erb_open_tag_node->content = content;
+  erb_open_tag_node->tag_closing = tag_closing;
+  erb_open_tag_node->tag_name = tag_name;
   erb_open_tag_node->children = children;
 
   return erb_open_tag_node;
@@ -249,9 +249,9 @@ AST_HTML_COMMENT_NODE_T* ast_html_comment_node_init(token_T* comment_start, hb_a
 
   ast_node_init(&html_comment_node->base, AST_HTML_COMMENT_NODE, start_position, end_position, errors, allocator);
 
-  html_comment_node->comment_start = token_copy(comment_start, allocator);
+  html_comment_node->comment_start = comment_start;
   html_comment_node->children = children;
-  html_comment_node->comment_end = token_copy(comment_end, allocator);
+  html_comment_node->comment_end = comment_end;
 
   return html_comment_node;
 }
@@ -263,9 +263,9 @@ AST_HTML_DOCTYPE_NODE_T* ast_html_doctype_node_init(token_T* tag_opening, hb_arr
 
   ast_node_init(&html_doctype_node->base, AST_HTML_DOCTYPE_NODE, start_position, end_position, errors, allocator);
 
-  html_doctype_node->tag_opening = token_copy(tag_opening, allocator);
+  html_doctype_node->tag_opening = tag_opening;
   html_doctype_node->children = children;
-  html_doctype_node->tag_closing = token_copy(tag_closing, allocator);
+  html_doctype_node->tag_closing = tag_closing;
 
   return html_doctype_node;
 }
@@ -277,13 +277,28 @@ AST_XML_DECLARATION_NODE_T* ast_xml_declaration_node_init(token_T* tag_opening,
 
   ast_node_init(&xml_declaration_node->base, AST_XML_DECLARATION_NODE, start_position, end_position, errors, allocator);
 
-  xml_declaration_node->tag_opening = token_copy(tag_opening, allocator);
+  xml_declaration_node->tag_opening = tag_opening;
   xml_declaration_node->children = children;
-  xml_declaration_node->tag_closing = token_copy(tag_closing, allocator);
+  xml_declaration_node->tag_closing = tag_closing;
 
   return xml_declaration_node;
 }
 
+AST_XML_PROCESSING_INSTRUCTION_NODE_T* ast_xml_processing_instruction_node_init(token_T* tag_opening, token_T* target, hb_array_T* children, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+  AST_XML_PROCESSING_INSTRUCTION_NODE_T* xml_processing_instruction_node = hb_allocator_alloc(allocator, sizeof(AST_XML_PROCESSING_INSTRUCTION_NODE_T));
+
+  if (!xml_processing_instruction_node) { return NULL; }
+
+  ast_node_init(&xml_processing_instruction_node->base, AST_XML_PROCESSING_INSTRUCTION_NODE, start_position, end_position, errors, allocator);
+
+  xml_processing_instruction_node->tag_opening = tag_opening;
+  xml_processing_instruction_node->target = target;
+  xml_processing_instruction_node->children = children;
+  xml_processing_instruction_node->tag_closing = tag_closing;
+
+  return xml_processing_instruction_node;
+}
+
 AST_CDATA_NODE_T* ast_cdata_node_init(token_T* tag_opening, hb_array_T* children, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
   AST_CDATA_NODE_T* cdata_node = hb_allocator_alloc(allocator, sizeof(AST_CDATA_NODE_T));
 
@@ -291,9 +306,9 @@ AST_CDATA_NODE_T* ast_cdata_node_init(token_T* tag_opening, hb_array_T* children
 
   ast_node_init(&cdata_node->base, AST_CDATA_NODE, start_position, end_position, errors, allocator);
 
-  cdata_node->tag_opening = token_copy(tag_opening, allocator);
+  cdata_node->tag_opening = tag_opening;
   cdata_node->children = children;
-  cdata_node->tag_closing = token_copy(tag_closing, allocator);
+  cdata_node->tag_closing = tag_closing;
 
   return cdata_node;
 }
@@ -305,7 +320,7 @@ AST_WHITESPACE_NODE_T* ast_whitespace_node_init(token_T* value, position_T start
 
   ast_node_init(&whitespace_node->base, AST_WHITESPACE_NODE, start_position, end_position, errors, allocator);
 
-  whitespace_node->value = token_copy(value, allocator);
+  whitespace_node->value = value;
 
   return whitespace_node;
 }
@@ -317,9 +332,9 @@ AST_ERB_CONTENT_NODE_T* ast_erb_content_node_init(token_T* tag_opening, token_T*
 
   ast_node_init(&erb_content_node->base, AST_ERB_CONTENT_NODE, start_position, end_position, errors, allocator);
 
-  erb_content_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_content_node->content = token_copy(content, allocator);
-  erb_content_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_content_node->tag_opening = tag_opening;
+  erb_content_node->content = content;
+  erb_content_node->tag_closing = tag_closing;
   erb_content_node->analyzed_ruby = analyzed_ruby;
   erb_content_node->parsed = parsed;
   erb_content_node->valid = valid;
@@ -335,9 +350,9 @@ AST_ERB_END_NODE_T* ast_erb_end_node_init(token_T* tag_opening, token_T* content
 
   ast_node_init(&erb_end_node->base, AST_ERB_END_NODE, start_position, end_position, errors, allocator);
 
-  erb_end_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_end_node->content = token_copy(content, allocator);
-  erb_end_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_end_node->tag_opening = tag_opening;
+  erb_end_node->content = content;
+  erb_end_node->tag_closing = tag_closing;
 
   return erb_end_node;
 }
@@ -349,9 +364,9 @@ AST_ERB_ELSE_NODE_T* ast_erb_else_node_init(token_T* tag_opening, token_T* conte
 
   ast_node_init(&erb_else_node->base, AST_ERB_ELSE_NODE, start_position, end_position, errors, allocator);
 
-  erb_else_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_else_node->content = token_copy(content, allocator);
-  erb_else_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_else_node->tag_opening = tag_opening;
+  erb_else_node->content = content;
+  erb_else_node->tag_closing = tag_closing;
   erb_else_node->statements = statements;
 
   return erb_else_node;
@@ -364,9 +379,9 @@ AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content,
 
   ast_node_init(&erb_if_node->base, AST_ERB_IF_NODE, start_position, end_position, errors, allocator);
 
-  erb_if_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_if_node->content = token_copy(content, allocator);
-  erb_if_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_if_node->tag_opening = tag_opening;
+  erb_if_node->content = content;
+  erb_if_node->tag_closing = tag_closing;
   erb_if_node->then_keyword = then_keyword;
   erb_if_node->prism_node = prism_node;
   erb_if_node->statements = statements;
@@ -383,9 +398,9 @@ AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* con
 
   ast_node_init(&erb_block_node->base, AST_ERB_BLOCK_NODE, start_position, end_position, errors, allocator);
 
-  erb_block_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_block_node->content = token_copy(content, allocator);
-  erb_block_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_block_node->tag_opening = tag_opening;
+  erb_block_node->content = content;
+  erb_block_node->tag_closing = tag_closing;
   erb_block_node->prism_node = prism_node;
   erb_block_node->body = body;
   erb_block_node->block_arguments = block_arguments;
@@ -397,6 +412,32 @@ AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* con
   return erb_block_node;
 }
 
+AST_ERB_ITERATION_BLOCK_NODE_T* ast_erb_iteration_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, token_T* receiver, token_T* call_operator, token_T* message, hb_array_T* arguments, token_T* block_opening, hb_array_T* body, hb_array_T* block_arguments, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+  AST_ERB_ITERATION_BLOCK_NODE_T* erb_iteration_block_node = hb_allocator_alloc(allocator, sizeof(AST_ERB_ITERATION_BLOCK_NODE_T));
+
+  if (!erb_iteration_block_node) { return NULL; }
+
+  ast_node_init(&erb_iteration_block_node->base, AST_ERB_ITERATION_BLOCK_NODE, start_position, end_position, errors, allocator);
+
+  erb_iteration_block_node->tag_opening = tag_opening;
+  erb_iteration_block_node->content = content;
+  erb_iteration_block_node->tag_closing = tag_closing;
+  erb_iteration_block_node->prism_node = prism_node;
+  erb_iteration_block_node->receiver = receiver;
+  erb_iteration_block_node->call_operator = call_operator;
+  erb_iteration_block_node->message = message;
+  erb_iteration_block_node->arguments = arguments;
+  erb_iteration_block_node->block_opening = block_opening;
+  erb_iteration_block_node->body = body;
+  erb_iteration_block_node->block_arguments = block_arguments;
+  erb_iteration_block_node->rescue_clause = rescue_clause;
+  erb_iteration_block_node->else_clause = else_clause;
+  erb_iteration_block_node->ensure_clause = ensure_clause;
+  erb_iteration_block_node->end_node = end_node;
+
+  return erb_iteration_block_node;
+}
+
 AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
   AST_ERB_WHEN_NODE_T* erb_when_node = hb_allocator_alloc(allocator, sizeof(AST_ERB_WHEN_NODE_T));
 
@@ -404,9 +445,9 @@ AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* conte
 
   ast_node_init(&erb_when_node->base, AST_ERB_WHEN_NODE, start_position, end_position, errors, allocator);
 
-  erb_when_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_when_node->content = token_copy(content, allocator);
-  erb_when_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_when_node->tag_opening = tag_opening;
+  erb_when_node->content = content;
+  erb_when_node->tag_closing = tag_closing;
   erb_when_node->then_keyword = then_keyword;
   erb_when_node->statements = statements;
 
@@ -420,9 +461,9 @@ AST_ERB_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* conte
 
   ast_node_init(&erb_case_node->base, AST_ERB_CASE_NODE, start_position, end_position, errors, allocator);
 
-  erb_case_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_case_node->content = token_copy(content, allocator);
-  erb_case_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_case_node->tag_opening = tag_opening;
+  erb_case_node->content = content;
+  erb_case_node->tag_closing = tag_closing;
   erb_case_node->children = children;
   erb_case_node->prism_node = prism_node;
   erb_case_node->conditions = conditions;
@@ -439,9 +480,9 @@ AST_ERB_CASE_MATCH_NODE_T* ast_erb_case_match_node_init(token_T* tag_opening, to
 
   ast_node_init(&erb_case_match_node->base, AST_ERB_CASE_MATCH_NODE, start_position, end_position, errors, allocator);
 
-  erb_case_match_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_case_match_node->content = token_copy(content, allocator);
-  erb_case_match_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_case_match_node->tag_opening = tag_opening;
+  erb_case_match_node->content = content;
+  erb_case_match_node->tag_closing = tag_closing;
   erb_case_match_node->children = children;
   erb_case_match_node->prism_node = prism_node;
   erb_case_match_node->conditions = conditions;
@@ -458,9 +499,9 @@ AST_ERB_WHILE_NODE_T* ast_erb_while_node_init(token_T* tag_opening, token_T* con
 
   ast_node_init(&erb_while_node->base, AST_ERB_WHILE_NODE, start_position, end_position, errors, allocator);
 
-  erb_while_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_while_node->content = token_copy(content, allocator);
-  erb_while_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_while_node->tag_opening = tag_opening;
+  erb_while_node->content = content;
+  erb_while_node->tag_closing = tag_closing;
   erb_while_node->prism_node = prism_node;
   erb_while_node->statements = statements;
   erb_while_node->end_node = end_node;
@@ -475,9 +516,9 @@ AST_ERB_UNTIL_NODE_T* ast_erb_until_node_init(token_T* tag_opening, token_T* con
 
   ast_node_init(&erb_until_node->base, AST_ERB_UNTIL_NODE, start_position, end_position, errors, allocator);
 
-  erb_until_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_until_node->content = token_copy(content, allocator);
-  erb_until_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_until_node->tag_opening = tag_opening;
+  erb_until_node->content = content;
+  erb_until_node->tag_closing = tag_closing;
   erb_until_node->prism_node = prism_node;
   erb_until_node->statements = statements;
   erb_until_node->end_node = end_node;
@@ -492,9 +533,9 @@ AST_ERB_FOR_NODE_T* ast_erb_for_node_init(token_T* tag_opening, token_T* content
 
   ast_node_init(&erb_for_node->base, AST_ERB_FOR_NODE, start_position, end_position, errors, allocator);
 
-  erb_for_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_for_node->content = token_copy(content, allocator);
-  erb_for_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_for_node->tag_opening = tag_opening;
+  erb_for_node->content = content;
+  erb_for_node->tag_closing = tag_closing;
   erb_for_node->prism_node = prism_node;
   erb_for_node->statements = statements;
   erb_for_node->end_node = end_node;
@@ -509,9 +550,9 @@ AST_ERB_RESCUE_NODE_T* ast_erb_rescue_node_init(token_T* tag_opening, token_T* c
 
   ast_node_init(&erb_rescue_node->base, AST_ERB_RESCUE_NODE, start_position, end_position, errors, allocator);
 
-  erb_rescue_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_rescue_node->content = token_copy(content, allocator);
-  erb_rescue_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_rescue_node->tag_opening = tag_opening;
+  erb_rescue_node->content = content;
+  erb_rescue_node->tag_closing = tag_closing;
   erb_rescue_node->statements = statements;
   erb_rescue_node->subsequent = subsequent;
 
@@ -525,9 +566,9 @@ AST_ERB_ENSURE_NODE_T* ast_erb_ensure_node_init(token_T* tag_opening, token_T* c
 
   ast_node_init(&erb_ensure_node->base, AST_ERB_ENSURE_NODE, start_position, end_position, errors, allocator);
 
-  erb_ensure_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_ensure_node->content = token_copy(content, allocator);
-  erb_ensure_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_ensure_node->tag_opening = tag_opening;
+  erb_ensure_node->content = content;
+  erb_ensure_node->tag_closing = tag_closing;
   erb_ensure_node->statements = statements;
 
   return erb_ensure_node;
@@ -540,9 +581,9 @@ AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* con
 
   ast_node_init(&erb_begin_node->base, AST_ERB_BEGIN_NODE, start_position, end_position, errors, allocator);
 
-  erb_begin_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_begin_node->content = token_copy(content, allocator);
-  erb_begin_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_begin_node->tag_opening = tag_opening;
+  erb_begin_node->content = content;
+  erb_begin_node->tag_closing = tag_closing;
   erb_begin_node->prism_node = prism_node;
   erb_begin_node->statements = statements;
   erb_begin_node->rescue_clause = rescue_clause;
@@ -560,9 +601,9 @@ AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* c
 
   ast_node_init(&erb_unless_node->base, AST_ERB_UNLESS_NODE, start_position, end_position, errors, allocator);
 
-  erb_unless_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_unless_node->content = token_copy(content, allocator);
-  erb_unless_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_unless_node->tag_opening = tag_opening;
+  erb_unless_node->content = content;
+  erb_unless_node->tag_closing = tag_closing;
   erb_unless_node->then_keyword = then_keyword;
   erb_unless_node->prism_node = prism_node;
   erb_unless_node->statements = statements;
@@ -579,37 +620,39 @@ AST_RUBY_RENDER_LOCAL_NODE_T* ast_ruby_render_local_node_init(token_T* name, str
 
   ast_node_init(&ruby_render_local_node->base, AST_RUBY_RENDER_LOCAL_NODE, start_position, end_position, errors, allocator);
 
-  ruby_render_local_node->name = token_copy(name, allocator);
+  ruby_render_local_node->name = name;
   ruby_render_local_node->value = value;
 
   return ruby_render_local_node;
 }
 
-AST_RUBY_RENDER_KEYWORDS_NODE_T* ast_ruby_render_keywords_node_init(token_T* partial, token_T* template_path, token_T* layout, token_T* file, token_T* inline_template, token_T* body, token_T* plain, token_T* html, token_T* renderable, token_T* collection, token_T* object, token_T* as_name, token_T* spacer_template, token_T* formats, token_T* variants, token_T* handlers, token_T* content_type, hb_array_T* locals, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+AST_RUBY_RENDER_KEYWORDS_NODE_T* ast_ruby_render_keywords_node_init(token_T* partial, token_T* template_path, token_T* layout, token_T* file, token_T* inline_template, token_T* body, token_T* plain, token_T* html, token_T* renderable, token_T* collection, token_T* object, token_T* as_name, token_T* spacer_template, token_T* formats, token_T* variants, token_T* handlers, token_T* content_type, hb_array_T* locals, hb_array_T* state, location_T* state_location, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
   AST_RUBY_RENDER_KEYWORDS_NODE_T* ruby_render_keywords_node = hb_allocator_alloc(allocator, sizeof(AST_RUBY_RENDER_KEYWORDS_NODE_T));
 
   if (!ruby_render_keywords_node) { return NULL; }
 
   ast_node_init(&ruby_render_keywords_node->base, AST_RUBY_RENDER_KEYWORDS_NODE, start_position, end_position, errors, allocator);
 
-  ruby_render_keywords_node->partial = token_copy(partial, allocator);
-  ruby_render_keywords_node->template_path = token_copy(template_path, allocator);
-  ruby_render_keywords_node->layout = token_copy(layout, allocator);
-  ruby_render_keywords_node->file = token_copy(file, allocator);
-  ruby_render_keywords_node->inline_template = token_copy(inline_template, allocator);
-  ruby_render_keywords_node->body = token_copy(body, allocator);
-  ruby_render_keywords_node->plain = token_copy(plain, allocator);
-  ruby_render_keywords_node->html = token_copy(html, allocator);
-  ruby_render_keywords_node->renderable = token_copy(renderable, allocator);
-  ruby_render_keywords_node->collection = token_copy(collection, allocator);
-  ruby_render_keywords_node->object = token_copy(object, allocator);
-  ruby_render_keywords_node->as_name = token_copy(as_name, allocator);
-  ruby_render_keywords_node->spacer_template = token_copy(spacer_template, allocator);
-  ruby_render_keywords_node->formats = token_copy(formats, allocator);
-  ruby_render_keywords_node->variants = token_copy(variants, allocator);
-  ruby_render_keywords_node->handlers = token_copy(handlers, allocator);
-  ruby_render_keywords_node->content_type = token_copy(content_type, allocator);
+  ruby_render_keywords_node->partial = partial;
+  ruby_render_keywords_node->template_path = template_path;
+  ruby_render_keywords_node->layout = layout;
+  ruby_render_keywords_node->file = file;
+  ruby_render_keywords_node->inline_template = inline_template;
+  ruby_render_keywords_node->body = body;
+  ruby_render_keywords_node->plain = plain;
+  ruby_render_keywords_node->html = html;
+  ruby_render_keywords_node->renderable = renderable;
+  ruby_render_keywords_node->collection = collection;
+  ruby_render_keywords_node->object = object;
+  ruby_render_keywords_node->as_name = as_name;
+  ruby_render_keywords_node->spacer_template = spacer_template;
+  ruby_render_keywords_node->formats = formats;
+  ruby_render_keywords_node->variants = variants;
+  ruby_render_keywords_node->handlers = handlers;
+  ruby_render_keywords_node->content_type = content_type;
   ruby_render_keywords_node->locals = locals;
+  ruby_render_keywords_node->state = state;
+  ruby_render_keywords_node->state_location = state_location;
 
   return ruby_render_keywords_node;
 }
@@ -621,9 +664,9 @@ AST_ERB_RENDER_NODE_T* ast_erb_render_node_init(token_T* tag_opening, token_T* c
 
   ast_node_init(&erb_render_node->base, AST_ERB_RENDER_NODE, start_position, end_position, errors, allocator);
 
-  erb_render_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_render_node->content = token_copy(content, allocator);
-  erb_render_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_render_node->tag_opening = tag_opening;
+  erb_render_node->content = content;
+  erb_render_node->tag_closing = tag_closing;
   erb_render_node->analyzed_ruby = analyzed_ruby;
   erb_render_node->prism_node = prism_node;
   erb_render_node->keywords = keywords;
@@ -644,7 +687,7 @@ AST_RUBY_PARAMETER_NODE_T* ast_ruby_parameter_node_init(token_T* name, struct AS
 
   ast_node_init(&ruby_parameter_node->base, AST_RUBY_PARAMETER_NODE, start_position, end_position, errors, allocator);
 
-  ruby_parameter_node->name = token_copy(name, allocator);
+  ruby_parameter_node->name = name;
   ruby_parameter_node->default_value = default_value;
   ruby_parameter_node->kind = hb_string_copy(kind, allocator);
   ruby_parameter_node->required = required;
@@ -659,9 +702,9 @@ AST_ERB_STRICT_LOCALS_NODE_T* ast_erb_strict_locals_node_init(token_T* tag_openi
 
   ast_node_init(&erb_strict_locals_node->base, AST_ERB_STRICT_LOCALS_NODE, start_position, end_position, errors, allocator);
 
-  erb_strict_locals_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_strict_locals_node->content = token_copy(content, allocator);
-  erb_strict_locals_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_strict_locals_node->tag_opening = tag_opening;
+  erb_strict_locals_node->content = content;
+  erb_strict_locals_node->tag_closing = tag_closing;
   erb_strict_locals_node->analyzed_ruby = analyzed_ruby;
   erb_strict_locals_node->prism_node = prism_node;
   erb_strict_locals_node->locals = locals;
@@ -669,16 +712,17 @@ AST_ERB_STRICT_LOCALS_NODE_T* ast_erb_strict_locals_node_init(token_T* tag_openi
   return erb_strict_locals_node;
 }
 
-AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
   AST_ERB_YIELD_NODE_T* erb_yield_node = hb_allocator_alloc(allocator, sizeof(AST_ERB_YIELD_NODE_T));
 
   if (!erb_yield_node) { return NULL; }
 
   ast_node_init(&erb_yield_node->base, AST_ERB_YIELD_NODE, start_position, end_position, errors, allocator);
 
-  erb_yield_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_yield_node->content = token_copy(content, allocator);
-  erb_yield_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_yield_node->tag_opening = tag_opening;
+  erb_yield_node->content = content;
+  erb_yield_node->tag_closing = tag_closing;
+  erb_yield_node->prism_node = prism_node;
 
   return erb_yield_node;
 }
@@ -690,15 +734,76 @@ AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content,
 
   ast_node_init(&erb_in_node->base, AST_ERB_IN_NODE, start_position, end_position, errors, allocator);
 
-  erb_in_node->tag_opening = token_copy(tag_opening, allocator);
-  erb_in_node->content = token_copy(content, allocator);
-  erb_in_node->tag_closing = token_copy(tag_closing, allocator);
+  erb_in_node->tag_opening = tag_opening;
+  erb_in_node->content = content;
+  erb_in_node->tag_closing = tag_closing;
   erb_in_node->then_keyword = then_keyword;
   erb_in_node->statements = statements;
 
   return erb_in_node;
 }
 
+AST_HERB_DIRECTIVE_NODE_T* ast_herb_directive_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, token_T* key, token_T* arguments, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+  AST_HERB_DIRECTIVE_NODE_T* herb_directive_node = hb_allocator_alloc(allocator, sizeof(AST_HERB_DIRECTIVE_NODE_T));
+
+  if (!herb_directive_node) { return NULL; }
+
+  ast_node_init(&herb_directive_node->base, AST_HERB_DIRECTIVE_NODE, start_position, end_position, errors, allocator);
+
+  herb_directive_node->tag_opening = tag_opening;
+  herb_directive_node->content = content;
+  herb_directive_node->tag_closing = tag_closing;
+  herb_directive_node->key = key;
+  herb_directive_node->arguments = arguments;
+
+  return herb_directive_node;
+}
+
+AST_HERB_STATE_DECLARATION_NODE_T* ast_herb_state_declaration_node_init(token_T* name, struct AST_RUBY_LITERAL_NODE_STRUCT* default_value, hb_string_T kind, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+  AST_HERB_STATE_DECLARATION_NODE_T* herb_state_declaration_node = hb_allocator_alloc(allocator, sizeof(AST_HERB_STATE_DECLARATION_NODE_T));
+
+  if (!herb_state_declaration_node) { return NULL; }
+
+  ast_node_init(&herb_state_declaration_node->base, AST_HERB_STATE_DECLARATION_NODE, start_position, end_position, errors, allocator);
+
+  herb_state_declaration_node->name = name;
+  herb_state_declaration_node->default_value = default_value;
+  herb_state_declaration_node->kind = hb_string_copy(kind, allocator);
+
+  return herb_state_declaration_node;
+}
+
+AST_HERB_STATE_DIRECTIVE_NODE_T* ast_herb_state_directive_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, token_T* key, token_T* signature, hb_array_T* states, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+  AST_HERB_STATE_DIRECTIVE_NODE_T* herb_state_directive_node = hb_allocator_alloc(allocator, sizeof(AST_HERB_STATE_DIRECTIVE_NODE_T));
+
+  if (!herb_state_directive_node) { return NULL; }
+
+  ast_node_init(&herb_state_directive_node->base, AST_HERB_STATE_DIRECTIVE_NODE, start_position, end_position, errors, allocator);
+
+  herb_state_directive_node->tag_opening = tag_opening;
+  herb_state_directive_node->content = content;
+  herb_state_directive_node->tag_closing = tag_closing;
+  herb_state_directive_node->key = key;
+  herb_state_directive_node->signature = signature;
+  herb_state_directive_node->states = states;
+
+  return herb_state_directive_node;
+}
+
+AST_ERB_COMMENT_NODE_T* ast_erb_comment_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+  AST_ERB_COMMENT_NODE_T* erb_comment_node = hb_allocator_alloc(allocator, sizeof(AST_ERB_COMMENT_NODE_T));
+
+  if (!erb_comment_node) { return NULL; }
+
+  ast_node_init(&erb_comment_node->base, AST_ERB_COMMENT_NODE, start_position, end_position, errors, allocator);
+
+  erb_comment_node->tag_opening = tag_opening;
+  erb_comment_node->content = content;
+  erb_comment_node->tag_closing = tag_closing;
+
+  return erb_comment_node;
+}
+
 hb_string_T ast_node_type_to_string(AST_NODE_T* node) {
   switch (node->type) {
     case AST_DOCUMENT_NODE: return hb_string("AST_DOCUMENT_NODE");
@@ -720,6 +825,7 @@ hb_string_T ast_node_type_to_string(AST_NODE_T* node) {
     case AST_HTML_COMMENT_NODE: return hb_string("AST_HTML_COMMENT_NODE");
     case AST_HTML_DOCTYPE_NODE: return hb_string("AST_HTML_DOCTYPE_NODE");
     case AST_XML_DECLARATION_NODE: return hb_string("AST_XML_DECLARATION_NODE");
+    case AST_XML_PROCESSING_INSTRUCTION_NODE: return hb_string("AST_XML_PROCESSING_INSTRUCTION_NODE");
     case AST_CDATA_NODE: return hb_string("AST_CDATA_NODE");
     case AST_WHITESPACE_NODE: return hb_string("AST_WHITESPACE_NODE");
     case AST_ERB_CONTENT_NODE: return hb_string("AST_ERB_CONTENT_NODE");
@@ -727,6 +833,7 @@ hb_string_T ast_node_type_to_string(AST_NODE_T* node) {
     case AST_ERB_ELSE_NODE: return hb_string("AST_ERB_ELSE_NODE");
     case AST_ERB_IF_NODE: return hb_string("AST_ERB_IF_NODE");
     case AST_ERB_BLOCK_NODE: return hb_string("AST_ERB_BLOCK_NODE");
+    case AST_ERB_ITERATION_BLOCK_NODE: return hb_string("AST_ERB_ITERATION_BLOCK_NODE");
     case AST_ERB_WHEN_NODE: return hb_string("AST_ERB_WHEN_NODE");
     case AST_ERB_CASE_NODE: return hb_string("AST_ERB_CASE_NODE");
     case AST_ERB_CASE_MATCH_NODE: return hb_string("AST_ERB_CASE_MATCH_NODE");
@@ -744,6 +851,10 @@ hb_string_T ast_node_type_to_string(AST_NODE_T* node) {
     case AST_ERB_STRICT_LOCALS_NODE: return hb_string("AST_ERB_STRICT_LOCALS_NODE");
     case AST_ERB_YIELD_NODE: return hb_string("AST_ERB_YIELD_NODE");
     case AST_ERB_IN_NODE: return hb_string("AST_ERB_IN_NODE");
+    case AST_HERB_DIRECTIVE_NODE: return hb_string("AST_HERB_DIRECTIVE_NODE");
+    case AST_HERB_STATE_DECLARATION_NODE: return hb_string("AST_HERB_STATE_DECLARATION_NODE");
+    case AST_HERB_STATE_DIRECTIVE_NODE: return hb_string("AST_HERB_STATE_DIRECTIVE_NODE");
+    case AST_ERB_COMMENT_NODE: return hb_string("AST_ERB_COMMENT_NODE");
   }
 
   return hb_string("Unknown ast_node_type_T");
@@ -770,6 +881,7 @@ hb_string_T ast_node_human_type(AST_NODE_T* node) {
     case AST_HTML_COMMENT_NODE: return hb_string("HTMLCommentNode");
     case AST_HTML_DOCTYPE_NODE: return hb_string("HTMLDoctypeNode");
     case AST_XML_DECLARATION_NODE: return hb_string("XMLDeclarationNode");
+    case AST_XML_PROCESSING_INSTRUCTION_NODE: return hb_string("XMLProcessingInstructionNode");
     case AST_CDATA_NODE: return hb_string("CDATANode");
     case AST_WHITESPACE_NODE: return hb_string("WhitespaceNode");
     case AST_ERB_CONTENT_NODE: return hb_string("ERBContentNode");
@@ -777,6 +889,7 @@ hb_string_T ast_node_human_type(AST_NODE_T* node) {
     case AST_ERB_ELSE_NODE: return hb_string("ERBElseNode");
     case AST_ERB_IF_NODE: return hb_string("ERBIfNode");
     case AST_ERB_BLOCK_NODE: return hb_string("ERBBlockNode");
+    case AST_ERB_ITERATION_BLOCK_NODE: return hb_string("ERBIterationBlockNode");
     case AST_ERB_WHEN_NODE: return hb_string("ERBWhenNode");
     case AST_ERB_CASE_NODE: return hb_string("ERBCaseNode");
     case AST_ERB_CASE_MATCH_NODE: return hb_string("ERBCaseMatchNode");
@@ -794,6 +907,10 @@ hb_string_T ast_node_human_type(AST_NODE_T* node) {
     case AST_ERB_STRICT_LOCALS_NODE: return hb_string("ERBStrictLocalsNode");
     case AST_ERB_YIELD_NODE: return hb_string("ERBYieldNode");
     case AST_ERB_IN_NODE: return hb_string("ERBInNode");
+    case AST_HERB_DIRECTIVE_NODE: return hb_string("HerbDirectiveNode");
+    case AST_HERB_STATE_DECLARATION_NODE: return hb_string("HerbStateDeclarationNode");
+    case AST_HERB_STATE_DIRECTIVE_NODE: return hb_string("HerbStateDirectiveNode");
+    case AST_ERB_COMMENT_NODE: return hb_string("ERBCommentNode");
   }
 
   return hb_string("Unknown ast_node_type_T");
@@ -831,7 +948,7 @@ static void ast_free_document_node(AST_DOCUMENT_NODE_T* document_node, hb_alloca
 }
 
 static void ast_free_literal_node(AST_LITERAL_NODE_T* literal_node, hb_allocator_T* allocator) {
-  if (literal_node->content.data != NULL) { hb_allocator_dealloc(allocator, literal_node->content.data); }
+  if (!hb_string_is_empty(literal_node->content)) { hb_allocator_dealloc(allocator, literal_node->content.data); }
 
   ast_free_base_node(&literal_node->base, allocator);
 }
@@ -904,7 +1021,7 @@ static void ast_free_html_element_node(AST_HTML_ELEMENT_NODE_T* html_element_nod
 }
 
 static void ast_free_html_conditional_element_node(AST_HTML_CONDITIONAL_ELEMENT_NODE_T* html_conditional_element_node, hb_allocator_T* allocator) {
-  if (html_conditional_element_node->condition.data != NULL) { hb_allocator_dealloc(allocator, html_conditional_element_node->condition.data); }
+  if (!hb_string_is_empty(html_conditional_element_node->condition)) { hb_allocator_dealloc(allocator, html_conditional_element_node->condition.data); }
   ast_node_free((AST_NODE_T*) html_conditional_element_node->open_conditional, allocator);
   /* open_tag is a borrowed reference, not freed here (owned by another field) */
   if (html_conditional_element_node->body != NULL) {
@@ -959,14 +1076,14 @@ static void ast_free_html_attribute_node(AST_HTML_ATTRIBUTE_NODE_T* html_attribu
 }
 
 static void ast_free_ruby_literal_node(AST_RUBY_LITERAL_NODE_T* ruby_literal_node, hb_allocator_T* allocator) {
-  if (ruby_literal_node->content.data != NULL) { hb_allocator_dealloc(allocator, ruby_literal_node->content.data); }
+  if (!hb_string_is_empty(ruby_literal_node->content)) { hb_allocator_dealloc(allocator, ruby_literal_node->content.data); }
 
   ast_free_base_node(&ruby_literal_node->base, allocator);
 }
 
 static void ast_free_ruby_html_attributes_splat_node(AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T* ruby_html_attributes_splat_node, hb_allocator_T* allocator) {
-  if (ruby_html_attributes_splat_node->content.data != NULL) { hb_allocator_dealloc(allocator, ruby_html_attributes_splat_node->content.data); }
-  if (ruby_html_attributes_splat_node->prefix.data != NULL) { hb_allocator_dealloc(allocator, ruby_html_attributes_splat_node->prefix.data); }
+  if (!hb_string_is_empty(ruby_html_attributes_splat_node->content)) { hb_allocator_dealloc(allocator, ruby_html_attributes_splat_node->content.data); }
+  if (!hb_string_is_empty(ruby_html_attributes_splat_node->prefix)) { hb_allocator_dealloc(allocator, ruby_html_attributes_splat_node->prefix.data); }
 
   ast_free_base_node(&ruby_html_attributes_splat_node->base, allocator);
 }
@@ -989,7 +1106,7 @@ static void ast_free_erb_open_tag_node(AST_ERB_OPEN_TAG_NODE_T* erb_open_tag_nod
 }
 
 static void ast_free_html_text_node(AST_HTML_TEXT_NODE_T* html_text_node, hb_allocator_T* allocator) {
-  if (html_text_node->content.data != NULL) { hb_allocator_dealloc(allocator, html_text_node->content.data); }
+  if (!hb_string_is_empty(html_text_node->content)) { hb_allocator_dealloc(allocator, html_text_node->content.data); }
 
   ast_free_base_node(&html_text_node->base, allocator);
 }
@@ -1039,6 +1156,22 @@ static void ast_free_xml_declaration_node(AST_XML_DECLARATION_NODE_T* xml_declar
   ast_free_base_node(&xml_declaration_node->base, allocator);
 }
 
+static void ast_free_xml_processing_instruction_node(AST_XML_PROCESSING_INSTRUCTION_NODE_T* xml_processing_instruction_node, hb_allocator_T* allocator) {
+  if (xml_processing_instruction_node->tag_opening != NULL) { token_free(xml_processing_instruction_node->tag_opening, allocator); }
+  if (xml_processing_instruction_node->target != NULL) { token_free(xml_processing_instruction_node->target, allocator); }
+  if (xml_processing_instruction_node->children != NULL) {
+    for (size_t i = 0; i < hb_array_size(xml_processing_instruction_node->children); i++) {
+      AST_NODE_T* child = hb_array_get(xml_processing_instruction_node->children, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&xml_processing_instruction_node->children);
+  }
+  if (xml_processing_instruction_node->tag_closing != NULL) { token_free(xml_processing_instruction_node->tag_closing, allocator); }
+
+  ast_free_base_node(&xml_processing_instruction_node->base, allocator);
+}
+
 static void ast_free_cdata_node(AST_CDATA_NODE_T* cdata_node, hb_allocator_T* allocator) {
   if (cdata_node->tag_opening != NULL) { token_free(cdata_node->tag_opening, allocator); }
   if (cdata_node->children != NULL) {
@@ -1145,6 +1278,47 @@ static void ast_free_erb_block_node(AST_ERB_BLOCK_NODE_T* erb_block_node, hb_all
   ast_free_base_node(&erb_block_node->base, allocator);
 }
 
+static void ast_free_erb_iteration_block_node(AST_ERB_ITERATION_BLOCK_NODE_T* erb_iteration_block_node, hb_allocator_T* allocator) {
+  if (erb_iteration_block_node->tag_opening != NULL) { token_free(erb_iteration_block_node->tag_opening, allocator); }
+  if (erb_iteration_block_node->content != NULL) { token_free(erb_iteration_block_node->content, allocator); }
+  if (erb_iteration_block_node->tag_closing != NULL) { token_free(erb_iteration_block_node->tag_closing, allocator); }
+  /* prism_node is a borrowed reference into the prism context, not freed here */
+  if (erb_iteration_block_node->receiver != NULL) { token_free(erb_iteration_block_node->receiver, allocator); }
+  if (erb_iteration_block_node->call_operator != NULL) { token_free(erb_iteration_block_node->call_operator, allocator); }
+  if (erb_iteration_block_node->message != NULL) { token_free(erb_iteration_block_node->message, allocator); }
+  if (erb_iteration_block_node->arguments != NULL) {
+    for (size_t i = 0; i < hb_array_size(erb_iteration_block_node->arguments); i++) {
+      AST_NODE_T* child = hb_array_get(erb_iteration_block_node->arguments, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&erb_iteration_block_node->arguments);
+  }
+  if (erb_iteration_block_node->block_opening != NULL) { token_free(erb_iteration_block_node->block_opening, allocator); }
+  if (erb_iteration_block_node->body != NULL) {
+    for (size_t i = 0; i < hb_array_size(erb_iteration_block_node->body); i++) {
+      AST_NODE_T* child = hb_array_get(erb_iteration_block_node->body, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&erb_iteration_block_node->body);
+  }
+  if (erb_iteration_block_node->block_arguments != NULL) {
+    for (size_t i = 0; i < hb_array_size(erb_iteration_block_node->block_arguments); i++) {
+      AST_NODE_T* child = hb_array_get(erb_iteration_block_node->block_arguments, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&erb_iteration_block_node->block_arguments);
+  }
+  ast_node_free((AST_NODE_T*) erb_iteration_block_node->rescue_clause, allocator);
+  ast_node_free((AST_NODE_T*) erb_iteration_block_node->else_clause, allocator);
+  ast_node_free((AST_NODE_T*) erb_iteration_block_node->ensure_clause, allocator);
+  ast_node_free((AST_NODE_T*) erb_iteration_block_node->end_node, allocator);
+
+  ast_free_base_node(&erb_iteration_block_node->base, allocator);
+}
+
 static void ast_free_erb_when_node(AST_ERB_WHEN_NODE_T* erb_when_node, hb_allocator_T* allocator) {
   if (erb_when_node->tag_opening != NULL) { token_free(erb_when_node->tag_opening, allocator); }
   if (erb_when_node->content != NULL) { token_free(erb_when_node->content, allocator); }
@@ -1377,6 +1551,15 @@ static void ast_free_ruby_render_keywords_node(AST_RUBY_RENDER_KEYWORDS_NODE_T*
 
     hb_array_free(&ruby_render_keywords_node->locals);
   }
+  if (ruby_render_keywords_node->state != NULL) {
+    for (size_t i = 0; i < hb_array_size(ruby_render_keywords_node->state); i++) {
+      AST_NODE_T* child = hb_array_get(ruby_render_keywords_node->state, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&ruby_render_keywords_node->state);
+  }
+  if (ruby_render_keywords_node->state_location != NULL) { hb_allocator_dealloc(allocator, ruby_render_keywords_node->state_location); }
 
   ast_free_base_node(&ruby_render_keywords_node->base, allocator);
 }
@@ -1417,7 +1600,7 @@ static void ast_free_erb_render_node(AST_ERB_RENDER_NODE_T* erb_render_node, hb_
 static void ast_free_ruby_parameter_node(AST_RUBY_PARAMETER_NODE_T* ruby_parameter_node, hb_allocator_T* allocator) {
   if (ruby_parameter_node->name != NULL) { token_free(ruby_parameter_node->name, allocator); }
   ast_node_free((AST_NODE_T*) ruby_parameter_node->default_value, allocator);
-  if (ruby_parameter_node->kind.data != NULL) { hb_allocator_dealloc(allocator, ruby_parameter_node->kind.data); }
+  if (!hb_string_is_empty(ruby_parameter_node->kind)) { hb_allocator_dealloc(allocator, ruby_parameter_node->kind.data); }
 
   ast_free_base_node(&ruby_parameter_node->base, allocator);
 }
@@ -1446,6 +1629,7 @@ static void ast_free_erb_yield_node(AST_ERB_YIELD_NODE_T* erb_yield_node, hb_all
   if (erb_yield_node->tag_opening != NULL) { token_free(erb_yield_node->tag_opening, allocator); }
   if (erb_yield_node->content != NULL) { token_free(erb_yield_node->content, allocator); }
   if (erb_yield_node->tag_closing != NULL) { token_free(erb_yield_node->tag_closing, allocator); }
+  /* prism_node is a borrowed reference into the prism context, not freed here */
 
   ast_free_base_node(&erb_yield_node->base, allocator);
 }
@@ -1467,6 +1651,617 @@ static void ast_free_erb_in_node(AST_ERB_IN_NODE_T* erb_in_node, hb_allocator_T*
   ast_free_base_node(&erb_in_node->base, allocator);
 }
 
+static void ast_free_herb_directive_node(AST_HERB_DIRECTIVE_NODE_T* herb_directive_node, hb_allocator_T* allocator) {
+  if (herb_directive_node->tag_opening != NULL) { token_free(herb_directive_node->tag_opening, allocator); }
+  if (herb_directive_node->content != NULL) { token_free(herb_directive_node->content, allocator); }
+  if (herb_directive_node->tag_closing != NULL) { token_free(herb_directive_node->tag_closing, allocator); }
+  if (herb_directive_node->key != NULL) { token_free(herb_directive_node->key, allocator); }
+  if (herb_directive_node->arguments != NULL) { token_free(herb_directive_node->arguments, allocator); }
+
+  ast_free_base_node(&herb_directive_node->base, allocator);
+}
+
+static void ast_free_herb_state_declaration_node(AST_HERB_STATE_DECLARATION_NODE_T* herb_state_declaration_node, hb_allocator_T* allocator) {
+  if (herb_state_declaration_node->name != NULL) { token_free(herb_state_declaration_node->name, allocator); }
+  ast_node_free((AST_NODE_T*) herb_state_declaration_node->default_value, allocator);
+  if (!hb_string_is_empty(herb_state_declaration_node->kind)) { hb_allocator_dealloc(allocator, herb_state_declaration_node->kind.data); }
+
+  ast_free_base_node(&herb_state_declaration_node->base, allocator);
+}
+
+static void ast_free_herb_state_directive_node(AST_HERB_STATE_DIRECTIVE_NODE_T* herb_state_directive_node, hb_allocator_T* allocator) {
+  if (herb_state_directive_node->tag_opening != NULL) { token_free(herb_state_directive_node->tag_opening, allocator); }
+  if (herb_state_directive_node->content != NULL) { token_free(herb_state_directive_node->content, allocator); }
+  if (herb_state_directive_node->tag_closing != NULL) { token_free(herb_state_directive_node->tag_closing, allocator); }
+  if (herb_state_directive_node->key != NULL) { token_free(herb_state_directive_node->key, allocator); }
+  if (herb_state_directive_node->signature != NULL) { token_free(herb_state_directive_node->signature, allocator); }
+  if (herb_state_directive_node->states != NULL) {
+    for (size_t i = 0; i < hb_array_size(herb_state_directive_node->states); i++) {
+      AST_NODE_T* child = hb_array_get(herb_state_directive_node->states, i);
+      if (child) { ast_node_free(child, allocator); }
+    }
+
+    hb_array_free(&herb_state_directive_node->states);
+  }
+
+  ast_free_base_node(&herb_state_directive_node->base, allocator);
+}
+
+static void ast_free_erb_comment_node(AST_ERB_COMMENT_NODE_T* erb_comment_node, hb_allocator_T* allocator) {
+  if (erb_comment_node->tag_opening != NULL) { token_free(erb_comment_node->tag_opening, allocator); }
+  if (erb_comment_node->content != NULL) { token_free(erb_comment_node->content, allocator); }
+  if (erb_comment_node->tag_closing != NULL) { token_free(erb_comment_node->tag_closing, allocator); }
+
+  ast_free_base_node(&erb_comment_node->base, allocator);
+}
+
+static void ast_rebase_token(token_T* token, const char* from, const char* to, size_t length) {
+  if (token == NULL || token->value.data == NULL) { return; }
+  if (token->value.data < from || token->value.data >= from + length) { return; }
+
+  token->value.data = (char*) to + (token->value.data - from);
+}
+
+void ast_node_rebase_tokens(AST_NODE_T* node, const char* from, const char* to, size_t length) {
+  if (!node) { return; }
+
+  switch (node->type) {
+    case AST_DOCUMENT_NODE: {
+      AST_DOCUMENT_NODE_T* typed = (AST_DOCUMENT_NODE_T*) node;
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_LITERAL_NODE: {
+      break;
+    }
+    case AST_HTML_OPEN_TAG_NODE: {
+      AST_HTML_OPEN_TAG_NODE_T* typed = (AST_HTML_OPEN_TAG_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->tag_name, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_HTML_CONDITIONAL_OPEN_TAG_NODE: {
+      AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T* typed = (AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T*) node;
+      ast_node_rebase_tokens((AST_NODE_T*) typed->conditional, from, to, length);
+      ast_rebase_token(typed->tag_name, from, to, length);
+      break;
+    }
+    case AST_HTML_CLOSE_TAG_NODE: {
+      AST_HTML_CLOSE_TAG_NODE_T* typed = (AST_HTML_CLOSE_TAG_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->tag_name, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+    case AST_HTML_OMITTED_CLOSE_TAG_NODE: {
+      AST_HTML_OMITTED_CLOSE_TAG_NODE_T* typed = (AST_HTML_OMITTED_CLOSE_TAG_NODE_T*) node;
+      ast_rebase_token(typed->tag_name, from, to, length);
+      break;
+    }
+    case AST_HTML_VIRTUAL_CLOSE_TAG_NODE: {
+      AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T* typed = (AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T*) node;
+      ast_rebase_token(typed->tag_name, from, to, length);
+      break;
+    }
+    case AST_HTML_ELEMENT_NODE: {
+      AST_HTML_ELEMENT_NODE_T* typed = (AST_HTML_ELEMENT_NODE_T*) node;
+      ast_node_rebase_tokens((AST_NODE_T*) typed->open_tag, from, to, length);
+      ast_rebase_token(typed->tag_name, from, to, length);
+      if (typed->body != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->body); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->body, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->close_tag, from, to, length);
+      break;
+    }
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      AST_HTML_CONDITIONAL_ELEMENT_NODE_T* typed = (AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) node;
+      ast_node_rebase_tokens((AST_NODE_T*) typed->open_conditional, from, to, length);
+      if (typed->body != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->body); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->body, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->close_conditional, from, to, length);
+      ast_rebase_token(typed->tag_name, from, to, length);
+      break;
+    }
+    case AST_HTML_ATTRIBUTE_VALUE_NODE: {
+      AST_HTML_ATTRIBUTE_VALUE_NODE_T* typed = (AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
+      ast_rebase_token(typed->open_quote, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      ast_rebase_token(typed->close_quote, from, to, length);
+      break;
+    }
+    case AST_HTML_ATTRIBUTE_NAME_NODE: {
+      AST_HTML_ATTRIBUTE_NAME_NODE_T* typed = (AST_HTML_ATTRIBUTE_NAME_NODE_T*) node;
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_HTML_ATTRIBUTE_NODE: {
+      AST_HTML_ATTRIBUTE_NODE_T* typed = (AST_HTML_ATTRIBUTE_NODE_T*) node;
+      ast_node_rebase_tokens((AST_NODE_T*) typed->name, from, to, length);
+      ast_rebase_token(typed->equals, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->value, from, to, length);
+      break;
+    }
+    case AST_RUBY_LITERAL_NODE: {
+      break;
+    }
+    case AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE: {
+      break;
+    }
+    case AST_ERB_OPEN_TAG_NODE: {
+      AST_ERB_OPEN_TAG_NODE_T* typed = (AST_ERB_OPEN_TAG_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      ast_rebase_token(typed->tag_name, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_HTML_TEXT_NODE: {
+      break;
+    }
+    case AST_HTML_COMMENT_NODE: {
+      AST_HTML_COMMENT_NODE_T* typed = (AST_HTML_COMMENT_NODE_T*) node;
+      ast_rebase_token(typed->comment_start, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      ast_rebase_token(typed->comment_end, from, to, length);
+      break;
+    }
+    case AST_HTML_DOCTYPE_NODE: {
+      AST_HTML_DOCTYPE_NODE_T* typed = (AST_HTML_DOCTYPE_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+    case AST_XML_DECLARATION_NODE: {
+      AST_XML_DECLARATION_NODE_T* typed = (AST_XML_DECLARATION_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+    case AST_XML_PROCESSING_INSTRUCTION_NODE: {
+      AST_XML_PROCESSING_INSTRUCTION_NODE_T* typed = (AST_XML_PROCESSING_INSTRUCTION_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->target, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+    case AST_CDATA_NODE: {
+      AST_CDATA_NODE_T* typed = (AST_CDATA_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+    case AST_WHITESPACE_NODE: {
+      AST_WHITESPACE_NODE_T* typed = (AST_WHITESPACE_NODE_T*) node;
+      ast_rebase_token(typed->value, from, to, length);
+      break;
+    }
+    case AST_ERB_CONTENT_NODE: {
+      AST_ERB_CONTENT_NODE_T* typed = (AST_ERB_CONTENT_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+    case AST_ERB_END_NODE: {
+      AST_ERB_END_NODE_T* typed = (AST_ERB_END_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+    case AST_ERB_ELSE_NODE: {
+      AST_ERB_ELSE_NODE_T* typed = (AST_ERB_ELSE_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_ERB_IF_NODE: {
+      AST_ERB_IF_NODE_T* typed = (AST_ERB_IF_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->subsequent, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_BLOCK_NODE: {
+      AST_ERB_BLOCK_NODE_T* typed = (AST_ERB_BLOCK_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->body != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->body); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->body, i), from, to, length);
+        }
+      }
+      if (typed->block_arguments != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->block_arguments); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->block_arguments, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->rescue_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->else_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->ensure_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_ITERATION_BLOCK_NODE: {
+      AST_ERB_ITERATION_BLOCK_NODE_T* typed = (AST_ERB_ITERATION_BLOCK_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      ast_rebase_token(typed->receiver, from, to, length);
+      ast_rebase_token(typed->call_operator, from, to, length);
+      ast_rebase_token(typed->message, from, to, length);
+      if (typed->arguments != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->arguments); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->arguments, i), from, to, length);
+        }
+      }
+      ast_rebase_token(typed->block_opening, from, to, length);
+      if (typed->body != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->body); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->body, i), from, to, length);
+        }
+      }
+      if (typed->block_arguments != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->block_arguments); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->block_arguments, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->rescue_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->else_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->ensure_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_WHEN_NODE: {
+      AST_ERB_WHEN_NODE_T* typed = (AST_ERB_WHEN_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_ERB_CASE_NODE: {
+      AST_ERB_CASE_NODE_T* typed = (AST_ERB_CASE_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      if (typed->conditions != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->conditions); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->conditions, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->else_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_CASE_MATCH_NODE: {
+      AST_ERB_CASE_MATCH_NODE_T* typed = (AST_ERB_CASE_MATCH_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->children != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->children); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->children, i), from, to, length);
+        }
+      }
+      if (typed->conditions != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->conditions); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->conditions, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->else_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_WHILE_NODE: {
+      AST_ERB_WHILE_NODE_T* typed = (AST_ERB_WHILE_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_UNTIL_NODE: {
+      AST_ERB_UNTIL_NODE_T* typed = (AST_ERB_UNTIL_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_FOR_NODE: {
+      AST_ERB_FOR_NODE_T* typed = (AST_ERB_FOR_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_RESCUE_NODE: {
+      AST_ERB_RESCUE_NODE_T* typed = (AST_ERB_RESCUE_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->subsequent, from, to, length);
+      break;
+    }
+    case AST_ERB_ENSURE_NODE: {
+      AST_ERB_ENSURE_NODE_T* typed = (AST_ERB_ENSURE_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_ERB_BEGIN_NODE: {
+      AST_ERB_BEGIN_NODE_T* typed = (AST_ERB_BEGIN_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->rescue_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->else_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->ensure_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_ERB_UNLESS_NODE: {
+      AST_ERB_UNLESS_NODE_T* typed = (AST_ERB_UNLESS_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->else_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_RUBY_RENDER_LOCAL_NODE: {
+      AST_RUBY_RENDER_LOCAL_NODE_T* typed = (AST_RUBY_RENDER_LOCAL_NODE_T*) node;
+      ast_rebase_token(typed->name, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->value, from, to, length);
+      break;
+    }
+    case AST_RUBY_RENDER_KEYWORDS_NODE: {
+      AST_RUBY_RENDER_KEYWORDS_NODE_T* typed = (AST_RUBY_RENDER_KEYWORDS_NODE_T*) node;
+      ast_rebase_token(typed->partial, from, to, length);
+      ast_rebase_token(typed->template_path, from, to, length);
+      ast_rebase_token(typed->layout, from, to, length);
+      ast_rebase_token(typed->file, from, to, length);
+      ast_rebase_token(typed->inline_template, from, to, length);
+      ast_rebase_token(typed->body, from, to, length);
+      ast_rebase_token(typed->plain, from, to, length);
+      ast_rebase_token(typed->html, from, to, length);
+      ast_rebase_token(typed->renderable, from, to, length);
+      ast_rebase_token(typed->collection, from, to, length);
+      ast_rebase_token(typed->object, from, to, length);
+      ast_rebase_token(typed->as_name, from, to, length);
+      ast_rebase_token(typed->spacer_template, from, to, length);
+      ast_rebase_token(typed->formats, from, to, length);
+      ast_rebase_token(typed->variants, from, to, length);
+      ast_rebase_token(typed->handlers, from, to, length);
+      ast_rebase_token(typed->content_type, from, to, length);
+      if (typed->locals != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->locals); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->locals, i), from, to, length);
+        }
+      }
+      if (typed->state != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->state); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->state, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_ERB_RENDER_NODE: {
+      AST_ERB_RENDER_NODE_T* typed = (AST_ERB_RENDER_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->keywords, from, to, length);
+      if (typed->body != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->body); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->body, i), from, to, length);
+        }
+      }
+      if (typed->block_arguments != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->block_arguments); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->block_arguments, i), from, to, length);
+        }
+      }
+      ast_node_rebase_tokens((AST_NODE_T*) typed->rescue_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->else_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->ensure_clause, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->end_node, from, to, length);
+      break;
+    }
+    case AST_RUBY_PARAMETER_NODE: {
+      AST_RUBY_PARAMETER_NODE_T* typed = (AST_RUBY_PARAMETER_NODE_T*) node;
+      ast_rebase_token(typed->name, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->default_value, from, to, length);
+      break;
+    }
+    case AST_ERB_STRICT_LOCALS_NODE: {
+      AST_ERB_STRICT_LOCALS_NODE_T* typed = (AST_ERB_STRICT_LOCALS_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->locals != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->locals); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->locals, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_ERB_YIELD_NODE: {
+      AST_ERB_YIELD_NODE_T* typed = (AST_ERB_YIELD_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+    case AST_ERB_IN_NODE: {
+      AST_ERB_IN_NODE_T* typed = (AST_ERB_IN_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      if (typed->statements != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->statements); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->statements, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_HERB_DIRECTIVE_NODE: {
+      AST_HERB_DIRECTIVE_NODE_T* typed = (AST_HERB_DIRECTIVE_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      ast_rebase_token(typed->key, from, to, length);
+      ast_rebase_token(typed->arguments, from, to, length);
+      break;
+    }
+    case AST_HERB_STATE_DECLARATION_NODE: {
+      AST_HERB_STATE_DECLARATION_NODE_T* typed = (AST_HERB_STATE_DECLARATION_NODE_T*) node;
+      ast_rebase_token(typed->name, from, to, length);
+      ast_node_rebase_tokens((AST_NODE_T*) typed->default_value, from, to, length);
+      break;
+    }
+    case AST_HERB_STATE_DIRECTIVE_NODE: {
+      AST_HERB_STATE_DIRECTIVE_NODE_T* typed = (AST_HERB_STATE_DIRECTIVE_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      ast_rebase_token(typed->key, from, to, length);
+      ast_rebase_token(typed->signature, from, to, length);
+      if (typed->states != NULL) {
+        for (size_t i = 0; i < hb_array_size(typed->states); i++) {
+          ast_node_rebase_tokens((AST_NODE_T*) hb_array_get(typed->states, i), from, to, length);
+        }
+      }
+      break;
+    }
+    case AST_ERB_COMMENT_NODE: {
+      AST_ERB_COMMENT_NODE_T* typed = (AST_ERB_COMMENT_NODE_T*) node;
+      ast_rebase_token(typed->tag_opening, from, to, length);
+      ast_rebase_token(typed->content, from, to, length);
+      ast_rebase_token(typed->tag_closing, from, to, length);
+      break;
+    }
+  }
+}
+
 void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator) {
   if (!node) { return; }
 
@@ -1490,6 +2285,7 @@ void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator) {
     case AST_HTML_COMMENT_NODE: ast_free_html_comment_node((AST_HTML_COMMENT_NODE_T*) node, allocator); break;
     case AST_HTML_DOCTYPE_NODE: ast_free_html_doctype_node((AST_HTML_DOCTYPE_NODE_T*) node, allocator); break;
     case AST_XML_DECLARATION_NODE: ast_free_xml_declaration_node((AST_XML_DECLARATION_NODE_T*) node, allocator); break;
+    case AST_XML_PROCESSING_INSTRUCTION_NODE: ast_free_xml_processing_instruction_node((AST_XML_PROCESSING_INSTRUCTION_NODE_T*) node, allocator); break;
     case AST_CDATA_NODE: ast_free_cdata_node((AST_CDATA_NODE_T*) node, allocator); break;
     case AST_WHITESPACE_NODE: ast_free_whitespace_node((AST_WHITESPACE_NODE_T*) node, allocator); break;
     case AST_ERB_CONTENT_NODE: ast_free_erb_content_node((AST_ERB_CONTENT_NODE_T*) node, allocator); break;
@@ -1497,6 +2293,7 @@ void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator) {
     case AST_ERB_ELSE_NODE: ast_free_erb_else_node((AST_ERB_ELSE_NODE_T*) node, allocator); break;
     case AST_ERB_IF_NODE: ast_free_erb_if_node((AST_ERB_IF_NODE_T*) node, allocator); break;
     case AST_ERB_BLOCK_NODE: ast_free_erb_block_node((AST_ERB_BLOCK_NODE_T*) node, allocator); break;
+    case AST_ERB_ITERATION_BLOCK_NODE: ast_free_erb_iteration_block_node((AST_ERB_ITERATION_BLOCK_NODE_T*) node, allocator); break;
     case AST_ERB_WHEN_NODE: ast_free_erb_when_node((AST_ERB_WHEN_NODE_T*) node, allocator); break;
     case AST_ERB_CASE_NODE: ast_free_erb_case_node((AST_ERB_CASE_NODE_T*) node, allocator); break;
     case AST_ERB_CASE_MATCH_NODE: ast_free_erb_case_match_node((AST_ERB_CASE_MATCH_NODE_T*) node, allocator); break;
@@ -1514,5 +2311,9 @@ void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator) {
     case AST_ERB_STRICT_LOCALS_NODE: ast_free_erb_strict_locals_node((AST_ERB_STRICT_LOCALS_NODE_T*) node, allocator); break;
     case AST_ERB_YIELD_NODE: ast_free_erb_yield_node((AST_ERB_YIELD_NODE_T*) node, allocator); break;
     case AST_ERB_IN_NODE: ast_free_erb_in_node((AST_ERB_IN_NODE_T*) node, allocator); break;
+    case AST_HERB_DIRECTIVE_NODE: ast_free_herb_directive_node((AST_HERB_DIRECTIVE_NODE_T*) node, allocator); break;
+    case AST_HERB_STATE_DECLARATION_NODE: ast_free_herb_state_declaration_node((AST_HERB_STATE_DECLARATION_NODE_T*) node, allocator); break;
+    case AST_HERB_STATE_DIRECTIVE_NODE: ast_free_herb_state_directive_node((AST_HERB_STATE_DIRECTIVE_NODE_T*) node, allocator); break;
+    case AST_ERB_COMMENT_NODE: ast_free_erb_comment_node((AST_ERB_COMMENT_NODE_T*) node, allocator); break;
   }
 }