herb 0.10.4-x86_64-linux-gnu → 0.11.1-x86_64-linux-gnu

data/src/include/analyze/analyze.h

@@ -4,44 +4,33 @@
 #include "../ast/ast_nodes.h"
 #include "../lib/hb_allocator.h"
 #include "../lib/hb_array.h"
+#include "../lib/hb_buffer.h"
 #include "../parser/parser.h"
 #include "analyzed_ruby.h"
 
+typedef struct TAG_HELPER_SCOPE_STRUCT {
+  hb_buffer_T buffer;
+  pm_options_t options;
+  pm_parser_t parser;
+  pm_node_t* root;
+} tag_helper_scope_T;
+
 typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   AST_DOCUMENT_NODE_T* document;
   AST_NODE_T* parent;
   hb_array_T* ruby_context_stack;
+  tag_helper_scope_T* tag_helper_scope;
   hb_allocator_T* allocator;
   const char* source;
   bool found_strict_locals;
+  const parser_options_T* options;
 } analyze_ruby_context_T;
 
-typedef enum {
-  CONTROL_TYPE_IF,
-  CONTROL_TYPE_ELSIF,
-  CONTROL_TYPE_ELSE,
-  CONTROL_TYPE_END,
-  CONTROL_TYPE_CASE,
-  CONTROL_TYPE_CASE_MATCH,
-  CONTROL_TYPE_WHEN,
-  CONTROL_TYPE_IN,
-  CONTROL_TYPE_BEGIN,
-  CONTROL_TYPE_RESCUE,
-  CONTROL_TYPE_ENSURE,
-  CONTROL_TYPE_UNLESS,
-  CONTROL_TYPE_WHILE,
-  CONTROL_TYPE_UNTIL,
-  CONTROL_TYPE_FOR,
-  CONTROL_TYPE_BLOCK,
-  CONTROL_TYPE_BLOCK_CLOSE,
-  CONTROL_TYPE_YIELD,
-  CONTROL_TYPE_UNKNOWN
-} control_type_t;
-
 typedef struct {
   int loop_depth;
   int rescue_depth;
   hb_allocator_T* allocator;
+  const parser_options_T* options;
 } invalid_erb_context_T;
 
 void herb_analyze_parse_errors(

data/src/include/analyze/analyzed_ruby.h

@@ -5,6 +5,29 @@
 #include "../lib/hb_string.h"
 
 #include <prism.h>
+#include <stdbool.h>
+
+typedef enum {
+  CONTROL_TYPE_IF,
+  CONTROL_TYPE_ELSIF,
+  CONTROL_TYPE_ELSE,
+  CONTROL_TYPE_END,
+  CONTROL_TYPE_CASE,
+  CONTROL_TYPE_CASE_MATCH,
+  CONTROL_TYPE_WHEN,
+  CONTROL_TYPE_IN,
+  CONTROL_TYPE_BEGIN,
+  CONTROL_TYPE_RESCUE,
+  CONTROL_TYPE_ENSURE,
+  CONTROL_TYPE_UNLESS,
+  CONTROL_TYPE_WHILE,
+  CONTROL_TYPE_UNTIL,
+  CONTROL_TYPE_FOR,
+  CONTROL_TYPE_BLOCK,
+  CONTROL_TYPE_BLOCK_CLOSE,
+  CONTROL_TYPE_YIELD,
+  CONTROL_TYPE_UNKNOWN
+} control_type_t;
 
 typedef struct ANALYZED_RUBY_STRUCT {
   pm_parser_t parser;
@@ -31,6 +54,8 @@ typedef struct ANALYZED_RUBY_STRUCT {
   int yield_node_count;
   int then_keyword_count;
   int unclosed_control_flow_count;
+  control_type_t control_type;
+  bool control_type_detected;
 } analyzed_ruby_T;
 
 analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);

data/src/include/analyze/builders.h

@@ -7,8 +7,24 @@
 #include "../location/position.h"
 #include "analyze.h"
 
+position_T erb_tag_start_position(const token_T* tag_opening, const token_T* content, location_T location);
+position_T erb_tag_end_position(
+  const token_T* tag_closing,
+  const token_T* content,
+  const token_T* tag_opening,
+  location_T location
+);
+
+position_T erb_content_start_position(const AST_ERB_CONTENT_NODE_T* erb_node);
 position_T erb_content_end_position(const AST_ERB_CONTENT_NODE_T* erb_node);
 
+location_T* compute_then_keyword_for_content(
+  token_T* content,
+  analyzed_ruby_T* analyzed_ruby,
+  control_type_t control_type,
+  hb_allocator_T* allocator
+);
+
 location_T* compute_then_keyword(
   AST_ERB_CONTENT_NODE_T* erb_node,
   control_type_t control_type,

data/src/include/analyze/helpers.h

@@ -8,6 +8,7 @@
 #include "../ast/ast_nodes.h"
 #include "../lib/hb_allocator.h"
 #include "../lib/hb_array.h"
+#include "../parser/parser.h"
 #include "analyzed_ruby.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed);
@@ -30,6 +31,9 @@ bool has_unless_node(analyzed_ruby_T* analyzed);
 bool has_yield_node(analyzed_ruby_T* analyzed);
 bool has_then_keyword(analyzed_ruby_T* analyzed);
 bool has_inline_case_condition(analyzed_ruby_T* analyzed);
+bool has_inline_pattern_match(analyzed_ruby_T* analyzed, hb_string_T content);
+bool inline_condition_keyword_offset(const analyzed_ruby_T* analyzed, uint32_t* offset);
+bool control_role_split_offset(const analyzed_ruby_T* analyzed, uint32_t* offset);
 
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
@@ -38,31 +42,11 @@ bool is_brace_block(pm_location_t opening_location);
 bool is_closing_brace(pm_location_t location);
 bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc);
 
-bool search_begin_nodes(const pm_node_t* node, void* data);
-bool search_block_nodes(const pm_node_t* node, void* data);
-bool search_case_match_nodes(const pm_node_t* node, void* data);
-bool search_case_nodes(const pm_node_t* node, void* data);
-bool search_for_nodes(const pm_node_t* node, void* data);
-bool search_if_nodes(const pm_node_t* node, void* data);
-bool search_in_nodes(const pm_node_t* node, void* data);
-bool search_then_keywords(const pm_node_t* node, void* data);
+bool search_control_flow_nodes(const pm_node_t* node, void* data);
 bool search_unclosed_control_flows(const pm_node_t* node, void* data);
-bool search_unless_nodes(const pm_node_t* node, void* data);
-bool search_until_nodes(const pm_node_t* node, void* data);
-bool search_when_nodes(const pm_node_t* node, void* data);
-bool search_while_nodes(const pm_node_t* node, void* data);
-bool search_yield_nodes(const pm_node_t* node, void* data);
+void search_unexpected_keyword_errors(analyzed_ruby_T* analyzed);
 
-bool search_unexpected_block_closing_nodes(analyzed_ruby_T* analyzed);
-bool search_unexpected_else_nodes(analyzed_ruby_T* analyzed);
-bool search_unexpected_elsif_nodes(analyzed_ruby_T* analyzed);
-bool search_unexpected_end_nodes(analyzed_ruby_T* analyzed);
-bool search_unexpected_ensure_nodes(analyzed_ruby_T* analyzed);
-bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed);
-bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed);
-bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed);
-
-void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator);
+void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator, const parser_options_T* options);
 
 hb_array_T* extract_parameters_from_prism(
   pm_parameters_node_t* parameters,
@@ -73,10 +57,27 @@ hb_array_T* extract_parameters_from_prism(
   hb_allocator_T* allocator
 );
 
+bool is_erb_output_tag(const AST_ERB_CONTENT_NODE_T* erb_node);
+
+typedef enum {
+  STATIC_OUTPUT_NODE_NONE,
+  STATIC_OUTPUT_NODE_HTML_TEXT,
+  STATIC_OUTPUT_NODE_LITERAL,
+} static_output_node_type_T;
+
+bool append_static_output_node(
+  hb_array_T* statements,
+  const pm_statements_node_t* body,
+  const analyzed_ruby_T* analyzed,
+  position_T content_start,
+  static_output_node_type_T node_type,
+  hb_allocator_T* allocator
+);
+
 hb_array_T* extract_block_arguments_from_erb_node(
   const AST_ERB_CONTENT_NODE_T* erb_node,
   const char* source,
-  hb_array_T* errors,
+  hb_array_T** errors,
   hb_allocator_T* allocator
 );
 

data/src/include/analyze/herb_directive_kinds.h

@@ -0,0 +1,41 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See templates/src/include/analyze/herb_directive_kinds.h.erb
+
+#ifndef HERB_DIRECTIVE_KINDS_H
+#define HERB_DIRECTIVE_KINDS_H
+
+#include <prism.h>
+
+/**
+ * The kind a `herb:state` default gets from the Prism node it parsed into.
+ *
+ * Returns NULL for a node type that has no plain mapping. The caller decides what those become,
+ * since a call node is a bare read or a seed depending on its shape.
+ */
+static inline const char* herb_directive_kind_for_prism_type(pm_node_type_t type) {
+  switch (type) {
+    case PM_TRUE_NODE:
+    case PM_FALSE_NODE: return "boolean";
+
+    case PM_INTEGER_NODE: return "integer";
+
+    case PM_FLOAT_NODE: return "float";
+
+    case PM_STRING_NODE: return "string";
+
+    case PM_SYMBOL_NODE: return "symbol";
+
+    case PM_NIL_NODE: return "nil";
+
+    case PM_ARRAY_NODE: return "array";
+
+    case PM_HASH_NODE:
+    case PM_KEYWORD_HASH_NODE: return "hash";
+
+    case PM_LOCAL_VARIABLE_READ_NODE: return "bare";
+
+    default: return NULL;
+  }
+}
+
+#endif

data/src/include/analyze/herb_directives.h

@@ -0,0 +1,14 @@
+#ifndef HERB_ANALYZE_HERB_DIRECTIVES_H
+#define HERB_ANALYZE_HERB_DIRECTIVES_H
+
+#include "../ast/ast_nodes.h"
+#include "../lib/hb_string.h"
+#include "analyze.h"
+
+#include <prism.h>
+#include <stdbool.h>
+
+bool transform_herb_directive_nodes(const AST_NODE_T* node, void* data);
+hb_string_T herb_directive_kind_for_prism_node(const pm_node_t* node);
+
+#endif

data/src/include/analyze/iteration_nodes.h

@@ -0,0 +1,11 @@
+#ifndef HERB_ANALYZE_ITERATION_NODES_H
+#define HERB_ANALYZE_ITERATION_NODES_H
+
+#include "../ast/ast_nodes.h"
+#include "analyze.h"
+
+#include <stdbool.h>
+
+bool transform_iteration_nodes(const AST_NODE_T* node, void* data);
+
+#endif

data/src/include/analyze/prism_annotate.h

@@ -4,12 +4,12 @@
 #include "../ast/ast_nodes.h"
 #include "../lib/hb_allocator.h"
 
+struct PARSER_OPTIONS_STRUCT;
+
 void herb_annotate_prism_nodes(
   AST_DOCUMENT_NODE_T* document,
   const char* source,
-  bool prism_nodes,
-  bool prism_nodes_deep,
-  bool prism_program,
+  const struct PARSER_OPTIONS_STRUCT* options,
   hb_allocator_T* allocator
 );
 

data/src/include/analyze/ternary_conditionals.h

@@ -3,10 +3,12 @@
 
 #include "../ast/ast_nodes.h"
 #include "analyze.h"
+#include "helpers.h"
 
 AST_NODE_T* transform_ternary_expression(
   AST_ERB_CONTENT_NODE_T* erb_node,
   pm_if_node_t* if_node,
+  static_output_node_type_T static_node_type,
   hb_allocator_T* allocator
 );
 

data/src/include/ast/ast_node.h

@@ -16,21 +16,17 @@ void ast_node_init(
   hb_allocator_T* allocator
 );
 void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator);
+void ast_node_rebase_tokens(AST_NODE_T* node, const char* from, const char* to, size_t length);
 
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token, hb_allocator_T* allocator);
 
 size_t ast_node_sizeof(void);
-size_t ast_node_child_count(AST_NODE_T* node);
 
 ast_node_type_T ast_node_type(const AST_NODE_T* node);
 
 void ast_node_set_start(AST_NODE_T* node, position_T position);
 void ast_node_set_end(AST_NODE_T* node, position_T position);
 
-size_t ast_node_errors_count(const AST_NODE_T* node);
-hb_array_T* ast_node_errors(const AST_NODE_T* node);
-void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error);
-
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token);
 void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token);
 

data/src/include/ast/ast_nodes.h

@@ -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/include/ast/ast_nodes.h.erb
+// be modified manually. See templates/src/include/ast/ast_nodes.h.erb
 
 #ifndef HERB_AST_NODES_H
 #define HERB_AST_NODES_H
@@ -39,6 +39,7 @@ typedef enum {
   AST_HTML_COMMENT_NODE,
   AST_HTML_DOCTYPE_NODE,
   AST_XML_DECLARATION_NODE,
+  AST_XML_PROCESSING_INSTRUCTION_NODE,
   AST_CDATA_NODE,
   AST_WHITESPACE_NODE,
   AST_ERB_CONTENT_NODE,
@@ -46,6 +47,7 @@ typedef enum {
   AST_ERB_ELSE_NODE,
   AST_ERB_IF_NODE,
   AST_ERB_BLOCK_NODE,
+  AST_ERB_ITERATION_BLOCK_NODE,
   AST_ERB_WHEN_NODE,
   AST_ERB_CASE_NODE,
   AST_ERB_CASE_MATCH_NODE,
@@ -63,6 +65,10 @@ typedef enum {
   AST_ERB_STRICT_LOCALS_NODE,
   AST_ERB_YIELD_NODE,
   AST_ERB_IN_NODE,
+  AST_HERB_DIRECTIVE_NODE,
+  AST_HERB_STATE_DECLARATION_NODE,
+  AST_HERB_STATE_DIRECTIVE_NODE,
+  AST_ERB_COMMENT_NODE,
 } ast_node_type_T;
 
 typedef struct AST_NODE_STRUCT {
@@ -207,6 +213,14 @@ typedef struct AST_XML_DECLARATION_NODE_STRUCT {
   token_T* tag_closing;
 } AST_XML_DECLARATION_NODE_T;
 
+typedef struct AST_XML_PROCESSING_INSTRUCTION_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* target;
+  hb_array_T* children;
+  token_T* tag_closing;
+} AST_XML_PROCESSING_INSTRUCTION_NODE_T;
+
 typedef struct AST_CDATA_NODE_STRUCT {
   AST_NODE_T base;
   token_T* tag_opening;
@@ -271,6 +285,25 @@ typedef struct AST_ERB_BLOCK_NODE_STRUCT {
   struct AST_ERB_END_NODE_STRUCT* end_node;
 } AST_ERB_BLOCK_NODE_T;
 
+typedef struct AST_ERB_ITERATION_BLOCK_NODE_STRUCT {
+  AST_NODE_T base;
+  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;
+} AST_ERB_ITERATION_BLOCK_NODE_T;
+
 typedef struct AST_ERB_WHEN_NODE_STRUCT {
   AST_NODE_T base;
   token_T* tag_opening;
@@ -402,6 +435,8 @@ typedef struct AST_RUBY_RENDER_KEYWORDS_NODE_STRUCT {
   token_T* handlers;
   token_T* content_type;
   hb_array_T* locals;
+  hb_array_T* state;
+  location_T* state_location;
 } AST_RUBY_RENDER_KEYWORDS_NODE_T;
 
 typedef struct AST_ERB_RENDER_NODE_STRUCT {
@@ -443,6 +478,7 @@ typedef struct AST_ERB_YIELD_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  herb_prism_node_T prism_node;
 } AST_ERB_YIELD_NODE_T;
 
 typedef struct AST_ERB_IN_NODE_STRUCT {
@@ -454,6 +490,39 @@ typedef struct AST_ERB_IN_NODE_STRUCT {
   hb_array_T* statements;
 } AST_ERB_IN_NODE_T;
 
+typedef struct AST_HERB_DIRECTIVE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  token_T* key;
+  token_T* arguments;
+} AST_HERB_DIRECTIVE_NODE_T;
+
+typedef struct AST_HERB_STATE_DECLARATION_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* name;
+  struct AST_RUBY_LITERAL_NODE_STRUCT* default_value;
+  hb_string_T kind;
+} AST_HERB_STATE_DECLARATION_NODE_T;
+
+typedef struct AST_HERB_STATE_DIRECTIVE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  token_T* key;
+  token_T* signature;
+  hb_array_T* states;
+} AST_HERB_STATE_DIRECTIVE_NODE_T;
+
+typedef struct AST_ERB_COMMENT_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+} AST_ERB_COMMENT_NODE_T;
+
 AST_DOCUMENT_NODE_T* ast_document_node_init(hb_array_T* children, herb_prism_context_T* prism_context, herb_prism_node_T prism_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_LITERAL_NODE_T* ast_literal_node_init(hb_string_T content, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_HTML_OPEN_TAG_NODE_T* ast_html_open_tag_node_init(token_T* tag_opening, token_T* tag_name, token_T* tag_closing, hb_array_T* children, bool is_void, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
@@ -473,6 +542,7 @@ AST_HTML_TEXT_NODE_T* ast_html_text_node_init(hb_string_T content, position_T st
 AST_HTML_COMMENT_NODE_T* ast_html_comment_node_init(token_T* comment_start, hb_array_T* children, token_T* comment_end, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_HTML_DOCTYPE_NODE_T* ast_html_doctype_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_XML_DECLARATION_NODE_T* ast_xml_declaration_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_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_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_WHITESPACE_NODE_T* ast_whitespace_node_init(token_T* value, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_CONTENT_NODE_T* ast_erb_content_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, bool parsed, bool valid, herb_prism_node_T prism_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
@@ -480,6 +550,7 @@ AST_ERB_END_NODE_T* ast_erb_end_node_init(token_T* tag_opening, token_T* content
 AST_ERB_ELSE_NODE_T* ast_erb_else_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, herb_prism_node_T prism_node, hb_array_T* statements, AST_NODE_T* subsequent, 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_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, 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* 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_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_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* children, herb_prism_node_T prism_node, hb_array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_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_CASE_MATCH_NODE_T* ast_erb_case_match_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* children, herb_prism_node_T prism_node, hb_array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_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);
@@ -491,12 +562,16 @@ AST_ERB_ENSURE_NODE_T* ast_erb_ensure_node_init(token_T* tag_opening, token_T* c
 AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, hb_array_T* statements, 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_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, herb_prism_node_T prism_node, hb_array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_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_RUBY_RENDER_LOCAL_NODE_T* ast_ruby_render_local_node_init(token_T* name, struct AST_RUBY_LITERAL_NODE_STRUCT* value, 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, 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_ERB_RENDER_NODE_T* ast_erb_render_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, herb_prism_node_T prism_node, struct AST_RUBY_RENDER_KEYWORDS_NODE_STRUCT* keywords, 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_RUBY_PARAMETER_NODE_T* ast_ruby_parameter_node_init(token_T* name, struct AST_RUBY_LITERAL_NODE_STRUCT* default_value, hb_string_T kind, bool required, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator);
 AST_ERB_STRICT_LOCALS_NODE_T* ast_erb_strict_locals_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, herb_prism_node_T prism_node, hb_array_T* locals, 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, 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_IN_NODE_T* ast_erb_in_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_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_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_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_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);
 
 hb_string_T ast_node_type_to_string(AST_NODE_T* node);
 hb_string_T ast_node_human_type(AST_NODE_T* node);

data/src/include/ast/ast_pretty_print.h

@@ -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/include/ast/ast_pretty_print.h.erb
+// be modified manually. See templates/src/include/ast/ast_pretty_print.h.erb
 
 #ifndef HERB_AST_PRETTY_PRINT_H
 #define HERB_AST_PRETTY_PRINT_H

data/src/include/diff/herb_diff.h

@@ -20,6 +20,7 @@ typedef enum {
   HERB_DIFF_NODE_MOVED,
 
   HERB_DIFF_TEXT_CHANGED,
+  HERB_DIFF_WHITESPACE_CHANGED,
   HERB_DIFF_ERB_CONTENT_CHANGED,
 
   HERB_DIFF_ATTRIBUTE_ADDED,
@@ -46,10 +47,17 @@ typedef struct {
   uint32_t new_index;
 } herb_diff_operation_T;
 
+typedef struct {
+  bool track_whitespace_changes;
+} herb_diff_options_T;
+
+extern const herb_diff_options_T HERB_DEFAULT_DIFF_OPTIONS;
+
 typedef struct {
   hb_array_T* operations;
   hb_allocator_T* allocator;
   bool trees_identical;
+  herb_diff_options_T options;
 } herb_diff_result_T;
 
 herb_diff_path_T herb_diff_path_empty(void);
@@ -58,6 +66,7 @@ herb_diff_path_T herb_diff_path_append(herb_diff_path_T path, uint32_t index);
 herb_diff_result_T* herb_diff(
   const AST_DOCUMENT_NODE_T* old_document,
   const AST_DOCUMENT_NODE_T* new_document,
+  const herb_diff_options_T* options,
   hb_allocator_T* allocator
 );
 
@@ -72,6 +81,7 @@ void herb_diff_node(
   herb_diff_path_T path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  bool preserve_whitespace,
   herb_diff_result_T* result
 );
 
@@ -81,6 +91,7 @@ void herb_diff_children(
   herb_diff_path_T parent_path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  bool preserve_whitespace,
   herb_diff_result_T* result
 );