herb 0.8.10-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/src/html_util.c

@@ -1,5 +1,5 @@
 #include "include/html_util.h"
-#include "include/util.h"
+#include "include/util/hb_allocator.h"
 #include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
 
@@ -10,22 +10,251 @@
 #include <string.h>
 
 // https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+static hb_string_T void_tags[] = HB_STRING_LIST(
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+);
+
+// https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
+static hb_string_T optional_end_tags[] = HB_STRING_LIST(
+  "li",
+  "dt",
+  "dd",
+  "p",
+  "rt",
+  "rp",
+  "optgroup",
+  "option",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "td",
+  "th",
+  "colgroup"
+);
+
+static hb_string_T p_closers[] = HB_STRING_LIST(
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "details",
+  "div",
+  "dl",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "main",
+  "menu",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "ul"
+);
+
+static hb_string_T p_parent_closers[] = HB_STRING_LIST(
+  "article",
+  "aside",
+  "blockquote",
+  "body",
+  "details",
+  "div",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "header",
+  "main",
+  "nav",
+  "section",
+  "td",
+  "th",
+  "li",
+  "dd",
+  "template"
+);
+
 bool is_void_element(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return false; }
 
-  hb_string_T void_tags[14] = {
-    hb_string("area"),  hb_string("base"),   hb_string("br"),    hb_string("col"),  hb_string("embed"),
-    hb_string("hr"),    hb_string("img"),    hb_string("input"), hb_string("link"), hb_string("meta"),
-    hb_string("param"), hb_string("source"), hb_string("track"), hb_string("wbr"),
-  };
-
-  for (size_t i = 0; i < 14; i++) {
+  for (size_t i = 0; i < sizeof(void_tags) / sizeof(void_tags[0]); i++) {
     if (hb_string_equals_case_insensitive(tag_name, void_tags[i])) { return true; }
   }
 
   return false;
 }
 
+bool has_optional_end_tag(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return false; }
+
+  for (size_t i = 0; i < sizeof(optional_end_tags) / sizeof(optional_end_tags[0]); i++) {
+    if (hb_string_equals_case_insensitive(tag_name, optional_end_tags[i])) { return true; }
+  }
+
+  return false;
+}
+
+static bool tag_in_list(hb_string_T tag_name, hb_string_T* list, size_t count) {
+  for (size_t i = 0; i < count; i++) {
+    if (hb_string_equals_case_insensitive(tag_name, list[i])) { return true; }
+  }
+
+  return false;
+}
+
+bool should_implicitly_close(hb_string_T open_tag_name, hb_string_T next_tag_name) {
+  if (hb_string_is_empty(open_tag_name)) { return false; }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("li"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("li"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("dt"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("dt"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("dd"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("dd"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("dd"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("dt"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("p"))) {
+    return tag_in_list(next_tag_name, p_closers, sizeof(p_closers) / sizeof(p_closers[0]));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("rt"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("rt"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("rp"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("rp"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("rp"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("rt"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("optgroup"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("optgroup"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("option"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("option"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("optgroup"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("thead"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("tbody"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("tfoot"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("tbody"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("tbody"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("tfoot"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("tr"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("tr"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("td"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("td"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("th"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("th"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("th"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("td"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("colgroup"))) {
+    return !hb_string_equals_case_insensitive(next_tag_name, hb_string("col"));
+  }
+
+  return false;
+}
+
+bool parent_closes_element(hb_string_T open_tag_name, hb_string_T parent_close_tag_name) {
+  if (hb_string_is_empty(open_tag_name)) { return false; }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("li"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("ul"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("ol"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("menu"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("dt"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("dd"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("dl"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("p"))) {
+    return tag_in_list(parent_close_tag_name, p_parent_closers, sizeof(p_parent_closers) / sizeof(p_parent_closers[0]));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("rt"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("rp"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("ruby"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("optgroup"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("option"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("select"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("datalist"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("thead"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("tbody"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("tfoot"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("table"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("tr"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("thead"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("tbody"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("tfoot"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("table"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("td"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("th"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("tr"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("colgroup"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("table"));
+  }
+
+  return false;
+}
+
 /**
  * @brief Creates a closing HTML tag string like "</tag_name>"
  *
@@ -41,9 +270,9 @@ bool is_void_element(hb_string_T tag_name) {
  * free(tag.data);
  * @endcode
  */
-hb_string_T html_closing_tag_string(hb_string_T tag_name) {
+hb_string_T html_closing_tag_string(hb_string_T tag_name, struct hb_allocator* allocator) {
   hb_buffer_T buffer;
-  hb_buffer_init(&buffer, tag_name.length + 3);
+  hb_buffer_init(&buffer, tag_name.length + 3, allocator);
 
   hb_buffer_append_char(&buffer, '<');
   hb_buffer_append_char(&buffer, '/');
@@ -67,9 +296,9 @@ hb_string_T html_closing_tag_string(hb_string_T tag_name) {
  * free(tag);
  * @endcode
  */
-hb_string_T html_self_closing_tag_string(hb_string_T tag_name) {
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name, struct hb_allocator* allocator) {
   hb_buffer_T buffer;
-  hb_buffer_init(&buffer, tag_name.length + 4);
+  hb_buffer_init(&buffer, tag_name.length + 4, allocator);
 
   hb_buffer_append_char(&buffer, '<');
   hb_buffer_append_string(&buffer, tag_name);

data/src/include/analyze/action_view/attribute_extraction_helpers.h

@@ -0,0 +1,36 @@
+#ifndef ATTRIBUTE_EXTRACTION_HELPERS_H
+#define ATTRIBUTE_EXTRACTION_HELPERS_H
+
+#include "../../util/hb_allocator.h"
+#include "tag_helper_handler.h"
+#include "tag_helpers.h"
+
+#include <prism.h>
+
+AST_HTML_ATTRIBUTE_NODE_T* extract_html_attribute_from_assoc(
+  pm_assoc_node_t* assoc,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+);
+
+hb_array_T* extract_html_attributes_from_keyword_hash(
+  pm_keyword_hash_node_t* kw_hash,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+);
+
+bool has_html_attributes_in_call(pm_call_node_t* call_node);
+
+hb_array_T* extract_html_attributes_from_call_node(
+  pm_call_node_t* call_node,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+);
+
+#endif

data/src/include/analyze/action_view/tag_helper_handler.h

@@ -0,0 +1,43 @@
+#ifndef TAG_HELPER_HANDLER_H
+#define TAG_HELPER_HANDLER_H
+
+#include "../../util/hb_allocator.h"
+#include "../../util/hb_array.h"
+#include "../../util/hb_string.h"
+#include <prism.h>
+#include <stdbool.h>
+
+typedef struct {
+  char* tag_name;
+  pm_call_node_t* call_node;
+  hb_array_T* attributes;
+  char* content;
+  bool content_is_ruby_expression;
+  bool has_block;
+  hb_allocator_T* allocator;
+} tag_helper_info_T;
+
+typedef struct {
+  const char* name;
+  hb_string_T source;
+  bool (*detect)(pm_call_node_t* call_node, pm_parser_t* parser);
+  char* (*extract_tag_name)(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator);
+  char* (*extract_content)(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator);
+  hb_array_T* (*extract_attributes)(
+    pm_call_node_t* call_node,
+    const uint8_t* source,
+    const char* original_source,
+    size_t erb_content_offset
+  );
+  bool (*supports_block)(void);
+} tag_helper_handler_T;
+
+tag_helper_info_T* tag_helper_info_init(hb_allocator_T* allocator);
+void tag_helper_info_free(tag_helper_info_T** info);
+
+tag_helper_handler_T* get_tag_helper_handlers(void);
+size_t get_tag_helper_handlers_count(void);
+
+char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator);
+
+#endif

data/src/include/analyze/action_view/tag_helper_node_builders.h

@@ -0,0 +1,70 @@
+#ifndef HERB_ANALYZE_TAG_HELPER_NODE_BUILDERS_H
+#define HERB_ANALYZE_TAG_HELPER_NODE_BUILDERS_H
+
+#include "../../ast_nodes.h"
+#include "../../position.h"
+#include "../../token_struct.h"
+#include "../../util/hb_allocator.h"
+#include "../../util/hb_array.h"
+
+#include <prism.h>
+
+token_T* create_synthetic_token(
+  hb_allocator_T* allocator,
+  const char* value,
+  token_type_T type,
+  position_T start,
+  position_T end
+);
+
+AST_HTML_ATTRIBUTE_NAME_NODE_T* create_attribute_name_node(
+  const char* name_string,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node(
+  const char* name_string,
+  const char* value_string,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
+  const char* name_string,
+  const char* ruby_content,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
+  const char* name_string,
+  pm_interpolated_string_node_t* interpolated_node,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+hb_array_T* prepend_attribute(hb_array_T* attributes, AST_NODE_T* attribute, hb_allocator_T* allocator);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_href_attribute(
+  const char* href,
+  bool is_ruby_expression,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+void append_body_content_node(
+  hb_array_T* body,
+  const char* content,
+  bool is_ruby_expression,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+);
+
+#endif

data/src/include/analyze/action_view/tag_helpers.h

@@ -0,0 +1,38 @@
+#ifndef HERB_ANALYZE_TAG_HELPERS_H
+#define HERB_ANALYZE_TAG_HELPERS_H
+
+#include "../../ast_nodes.h"
+#include "../../position.h"
+#include "../../util/hb_array.h"
+#include "../analyze.h"
+#include "tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+
+typedef struct {
+  const pm_node_t* tag_helper_node;
+  const uint8_t* source;
+  pm_parser_t* parser;
+  tag_helper_info_T* info;
+  const tag_helper_handler_T* matched_handler;
+  bool found;
+} tag_helper_search_data_T;
+
+bool search_tag_helper_node(const pm_node_t* node, void* data);
+
+position_T prism_location_to_position_with_offset(
+  const pm_location_t* pm_location,
+  const char* original_source,
+  size_t erb_content_offset,
+  const uint8_t* erb_content_source
+);
+
+position_T byte_offset_to_position(const char* source, size_t offset);
+
+size_t calculate_byte_offset_from_position(const char* source, position_T position);
+
+void transform_tag_helper_blocks(const AST_NODE_T* node, analyze_ruby_context_T* context);
+bool transform_tag_helper_nodes(const AST_NODE_T* node, void* data);
+
+#endif

data/src/include/{analyze.h → analyze/analyze.h}

@@ -1,14 +1,18 @@
 #ifndef HERB_ANALYZE_H
 #define HERB_ANALYZE_H
 
+#include "../ast_nodes.h"
+#include "../parser.h"
+#include "../util/hb_allocator.h"
+#include "../util/hb_array.h"
 #include "analyzed_ruby.h"
-#include "ast_nodes.h"
-#include "util/hb_array.h"
 
 typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   AST_DOCUMENT_NODE_T* document;
   AST_NODE_T* parent;
   hb_array_T* ruby_context_stack;
+  hb_allocator_T* allocator;
+  const char* source;
 } analyze_ruby_context_T;
 
 typedef enum {
@@ -36,10 +40,16 @@ typedef enum {
 typedef struct {
   int loop_depth;
   int rescue_depth;
+  hb_allocator_T* allocator;
 } invalid_erb_context_T;
 
-void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source);
-void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source);
+void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source, hb_allocator_T* allocator);
+void herb_analyze_parse_tree(
+  AST_DOCUMENT_NODE_T* document,
+  const char* source,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+);
 
 hb_array_T* rewrite_node_array(AST_NODE_T* node, hb_array_T* array, analyze_ruby_context_T* context);
 bool transform_erb_nodes(const AST_NODE_T* node, void* data);

data/src/include/{analyzed_ruby.h → analyze/analyzed_ruby.h}

@@ -1,8 +1,8 @@
 #ifndef HERB_ANALYZED_RUBY_H
 #define HERB_ANALYZED_RUBY_H
 
-#include "util/hb_array.h"
-#include "util/hb_string.h"
+#include "../util/hb_array.h"
+#include "../util/hb_string.h"
 
 #include <prism.h>
 
@@ -35,6 +35,6 @@ typedef struct ANALYZED_RUBY_STRUCT {
 
 analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);
 void free_analyzed_ruby(analyzed_ruby_T* analyzed);
-const char* erb_keyword_from_analyzed_ruby(const analyzed_ruby_T* analyzed);
+hb_string_T erb_keyword_from_analyzed_ruby(const analyzed_ruby_T* analyzed);
 
 #endif

data/src/include/analyze/builders.h

@@ -0,0 +1,27 @@
+#ifndef HERB_ANALYZE_BUILDERS_H
+#define HERB_ANALYZE_BUILDERS_H
+
+#include "../ast_nodes.h"
+#include "../location.h"
+#include "../position.h"
+#include "../util/hb_allocator.h"
+#include "analyze.h"
+
+position_T erb_content_end_position(const AST_ERB_CONTENT_NODE_T* erb_node);
+
+location_T* compute_then_keyword(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  control_type_t control_type,
+  hb_allocator_T* allocator
+);
+
+AST_NODE_T* create_control_node(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  hb_array_T* children,
+  AST_NODE_T* subsequent,
+  AST_ERB_END_NODE_T* end_node,
+  control_type_t control_type,
+  hb_allocator_T* allocator
+);
+
+#endif

data/src/include/analyze/conditional_elements.h

@@ -0,0 +1,9 @@
+#ifndef HERB_ANALYZE_CONDITIONAL_ELEMENTS_H
+#define HERB_ANALYZE_CONDITIONAL_ELEMENTS_H
+
+#include "../ast_nodes.h"
+#include "../util/hb_allocator.h"
+
+void herb_transform_conditional_elements(AST_DOCUMENT_NODE_T* document, hb_allocator_T* allocator);
+
+#endif

data/src/include/analyze/conditional_open_tags.h

@@ -0,0 +1,9 @@
+#ifndef HERB_ANALYZE_CONDITIONAL_OPEN_TAGS_H
+#define HERB_ANALYZE_CONDITIONAL_OPEN_TAGS_H
+
+#include "../ast_nodes.h"
+#include "../util/hb_allocator.h"
+
+void herb_transform_conditional_open_tags(AST_DOCUMENT_NODE_T* document, hb_allocator_T* allocator);
+
+#endif

data/src/include/analyze/control_type.h

@@ -0,0 +1,14 @@
+#ifndef HERB_ANALYZE_CONTROL_TYPE_H
+#define HERB_ANALYZE_CONTROL_TYPE_H
+
+#include "../ast_nodes.h"
+#include "analyze.h"
+
+#include <stdbool.h>
+
+control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node);
+bool is_subsequent_type(control_type_t parent_type, control_type_t child_type);
+bool is_terminator_type(control_type_t parent_type, control_type_t child_type);
+bool is_compound_control_type(control_type_t type);
+
+#endif

data/src/include/{analyze_helpers.h → analyze/helpers.h}

@@ -4,8 +4,9 @@
 #include <prism.h>
 #include <stdbool.h>
 
+#include "../ast_node.h"
+#include "../util/hb_allocator.h"
 #include "analyzed_ruby.h"
-#include "ast_node.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed);
 bool has_elsif_node(analyzed_ruby_T* analyzed);
@@ -26,6 +27,7 @@ bool has_ensure_node(analyzed_ruby_T* analyzed);
 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_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
@@ -58,6 +60,6 @@ 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);
+void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator);
 
 #endif

data/src/include/analyze/invalid_structures.h

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

data/src/include/analyze/prism_annotate.h

@@ -0,0 +1,16 @@
+#ifndef HERB_PRISM_ANNOTATE_H
+#define HERB_PRISM_ANNOTATE_H
+
+#include "../ast_nodes.h"
+#include "../util/hb_allocator.h"
+
+void herb_annotate_prism_nodes(
+  AST_DOCUMENT_NODE_T* document,
+  const char* source,
+  bool prism_nodes,
+  bool prism_nodes_deep,
+  bool prism_program,
+  hb_allocator_T* allocator
+);
+
+#endif

data/src/include/analyze/render_nodes.h

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