herb 0.8.3 → 0.8.4

data/src/ast_nodes.c

@@ -20,7 +20,11 @@ AST_DOCUMENT_NODE_T* ast_document_node_init(hb_array_T* children, position_T sta
 
   ast_node_init(&document_node->base, AST_DOCUMENT_NODE, start_position, end_position, errors);
 
-  document_node->children = children;
+  if (children == NULL) {
+    document_node->children = hb_array_init(8);
+  } else {
+    document_node->children = children;
+  }
 
   return document_node;
 }
@@ -43,7 +47,11 @@ AST_HTML_OPEN_TAG_NODE_T* ast_html_open_tag_node_init(token_T* tag_opening, toke
   html_open_tag_node->tag_opening = token_copy(tag_opening);
   html_open_tag_node->tag_name = token_copy(tag_name);
   html_open_tag_node->tag_closing = token_copy(tag_closing);
-  html_open_tag_node->children = children;
+  if (children == NULL) {
+    html_open_tag_node->children = hb_array_init(8);
+  } else {
+    html_open_tag_node->children = children;
+  }
   html_open_tag_node->is_void = is_void;
 
   return html_open_tag_node;
@@ -56,7 +64,11 @@ AST_HTML_CLOSE_TAG_NODE_T* ast_html_close_tag_node_init(token_T* tag_opening, to
 
   html_close_tag_node->tag_opening = token_copy(tag_opening);
   html_close_tag_node->tag_name = token_copy(tag_name);
-  html_close_tag_node->children = children;
+  if (children == NULL) {
+    html_close_tag_node->children = hb_array_init(8);
+  } else {
+    html_close_tag_node->children = children;
+  }
   html_close_tag_node->tag_closing = token_copy(tag_closing);
 
   return html_close_tag_node;
@@ -69,7 +81,11 @@ AST_HTML_ELEMENT_NODE_T* ast_html_element_node_init(struct AST_HTML_OPEN_TAG_NOD
 
   html_element_node->open_tag = open_tag;
   html_element_node->tag_name = token_copy(tag_name);
-  html_element_node->body = body;
+  if (body == NULL) {
+    html_element_node->body = hb_array_init(8);
+  } else {
+    html_element_node->body = body;
+  }
   html_element_node->close_tag = close_tag;
   html_element_node->is_void = is_void;
   html_element_node->source = source;
@@ -83,7 +99,11 @@ 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);
 
   html_attribute_value_node->open_quote = token_copy(open_quote);
-  html_attribute_value_node->children = children;
+  if (children == NULL) {
+    html_attribute_value_node->children = hb_array_init(8);
+  } else {
+    html_attribute_value_node->children = children;
+  }
   html_attribute_value_node->close_quote = token_copy(close_quote);
   html_attribute_value_node->quoted = quoted;
 
@@ -95,7 +115,11 @@ AST_HTML_ATTRIBUTE_NAME_NODE_T* ast_html_attribute_name_node_init(hb_array_T* ch
 
   ast_node_init(&html_attribute_name_node->base, AST_HTML_ATTRIBUTE_NAME_NODE, start_position, end_position, errors);
 
-  html_attribute_name_node->children = children;
+  if (children == NULL) {
+    html_attribute_name_node->children = hb_array_init(8);
+  } else {
+    html_attribute_name_node->children = children;
+  }
 
   return html_attribute_name_node;
 }
@@ -128,7 +152,11 @@ 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);
 
   html_comment_node->comment_start = token_copy(comment_start);
-  html_comment_node->children = children;
+  if (children == NULL) {
+    html_comment_node->children = hb_array_init(8);
+  } else {
+    html_comment_node->children = children;
+  }
   html_comment_node->comment_end = token_copy(comment_end);
 
   return html_comment_node;
@@ -140,7 +168,11 @@ 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);
 
   html_doctype_node->tag_opening = token_copy(tag_opening);
-  html_doctype_node->children = children;
+  if (children == NULL) {
+    html_doctype_node->children = hb_array_init(8);
+  } else {
+    html_doctype_node->children = children;
+  }
   html_doctype_node->tag_closing = token_copy(tag_closing);
 
   return html_doctype_node;
@@ -152,7 +184,11 @@ 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);
 
   xml_declaration_node->tag_opening = token_copy(tag_opening);
-  xml_declaration_node->children = children;
+  if (children == NULL) {
+    xml_declaration_node->children = hb_array_init(8);
+  } else {
+    xml_declaration_node->children = children;
+  }
   xml_declaration_node->tag_closing = token_copy(tag_closing);
 
   return xml_declaration_node;
@@ -164,7 +200,11 @@ 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);
 
   cdata_node->tag_opening = token_copy(tag_opening);
-  cdata_node->children = children;
+  if (children == NULL) {
+    cdata_node->children = hb_array_init(8);
+  } else {
+    cdata_node->children = children;
+  }
   cdata_node->tag_closing = token_copy(tag_closing);
 
   return cdata_node;
@@ -215,7 +255,11 @@ AST_ERB_ELSE_NODE_T* ast_erb_else_node_init(token_T* tag_opening, token_T* conte
   erb_else_node->tag_opening = token_copy(tag_opening);
   erb_else_node->content = token_copy(content);
   erb_else_node->tag_closing = token_copy(tag_closing);
-  erb_else_node->statements = statements;
+  if (statements == NULL) {
+    erb_else_node->statements = hb_array_init(8);
+  } else {
+    erb_else_node->statements = statements;
+  }
 
   return erb_else_node;
 }
@@ -228,7 +272,11 @@ AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content,
   erb_if_node->tag_opening = token_copy(tag_opening);
   erb_if_node->content = token_copy(content);
   erb_if_node->tag_closing = token_copy(tag_closing);
-  erb_if_node->statements = statements;
+  if (statements == NULL) {
+    erb_if_node->statements = hb_array_init(8);
+  } else {
+    erb_if_node->statements = statements;
+  }
   erb_if_node->subsequent = subsequent;
   erb_if_node->end_node = end_node;
 
@@ -243,7 +291,11 @@ AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* con
   erb_block_node->tag_opening = token_copy(tag_opening);
   erb_block_node->content = token_copy(content);
   erb_block_node->tag_closing = token_copy(tag_closing);
-  erb_block_node->body = body;
+  if (body == NULL) {
+    erb_block_node->body = hb_array_init(8);
+  } else {
+    erb_block_node->body = body;
+  }
   erb_block_node->end_node = end_node;
 
   return erb_block_node;
@@ -257,7 +309,11 @@ AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* conte
   erb_when_node->tag_opening = token_copy(tag_opening);
   erb_when_node->content = token_copy(content);
   erb_when_node->tag_closing = token_copy(tag_closing);
-  erb_when_node->statements = statements;
+  if (statements == NULL) {
+    erb_when_node->statements = hb_array_init(8);
+  } else {
+    erb_when_node->statements = statements;
+  }
 
   return erb_when_node;
 }
@@ -270,8 +326,16 @@ AST_ERB_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* conte
   erb_case_node->tag_opening = token_copy(tag_opening);
   erb_case_node->content = token_copy(content);
   erb_case_node->tag_closing = token_copy(tag_closing);
-  erb_case_node->children = children;
-  erb_case_node->conditions = conditions;
+  if (children == NULL) {
+    erb_case_node->children = hb_array_init(8);
+  } else {
+    erb_case_node->children = children;
+  }
+  if (conditions == NULL) {
+    erb_case_node->conditions = hb_array_init(8);
+  } else {
+    erb_case_node->conditions = conditions;
+  }
   erb_case_node->else_clause = else_clause;
   erb_case_node->end_node = end_node;
 
@@ -286,8 +350,16 @@ AST_ERB_CASE_MATCH_NODE_T* ast_erb_case_match_node_init(token_T* tag_opening, to
   erb_case_match_node->tag_opening = token_copy(tag_opening);
   erb_case_match_node->content = token_copy(content);
   erb_case_match_node->tag_closing = token_copy(tag_closing);
-  erb_case_match_node->children = children;
-  erb_case_match_node->conditions = conditions;
+  if (children == NULL) {
+    erb_case_match_node->children = hb_array_init(8);
+  } else {
+    erb_case_match_node->children = children;
+  }
+  if (conditions == NULL) {
+    erb_case_match_node->conditions = hb_array_init(8);
+  } else {
+    erb_case_match_node->conditions = conditions;
+  }
   erb_case_match_node->else_clause = else_clause;
   erb_case_match_node->end_node = end_node;
 
@@ -302,7 +374,11 @@ AST_ERB_WHILE_NODE_T* ast_erb_while_node_init(token_T* tag_opening, token_T* con
   erb_while_node->tag_opening = token_copy(tag_opening);
   erb_while_node->content = token_copy(content);
   erb_while_node->tag_closing = token_copy(tag_closing);
-  erb_while_node->statements = statements;
+  if (statements == NULL) {
+    erb_while_node->statements = hb_array_init(8);
+  } else {
+    erb_while_node->statements = statements;
+  }
   erb_while_node->end_node = end_node;
 
   return erb_while_node;
@@ -316,7 +392,11 @@ AST_ERB_UNTIL_NODE_T* ast_erb_until_node_init(token_T* tag_opening, token_T* con
   erb_until_node->tag_opening = token_copy(tag_opening);
   erb_until_node->content = token_copy(content);
   erb_until_node->tag_closing = token_copy(tag_closing);
-  erb_until_node->statements = statements;
+  if (statements == NULL) {
+    erb_until_node->statements = hb_array_init(8);
+  } else {
+    erb_until_node->statements = statements;
+  }
   erb_until_node->end_node = end_node;
 
   return erb_until_node;
@@ -330,7 +410,11 @@ AST_ERB_FOR_NODE_T* ast_erb_for_node_init(token_T* tag_opening, token_T* content
   erb_for_node->tag_opening = token_copy(tag_opening);
   erb_for_node->content = token_copy(content);
   erb_for_node->tag_closing = token_copy(tag_closing);
-  erb_for_node->statements = statements;
+  if (statements == NULL) {
+    erb_for_node->statements = hb_array_init(8);
+  } else {
+    erb_for_node->statements = statements;
+  }
   erb_for_node->end_node = end_node;
 
   return erb_for_node;
@@ -344,7 +428,11 @@ AST_ERB_RESCUE_NODE_T* ast_erb_rescue_node_init(token_T* tag_opening, token_T* c
   erb_rescue_node->tag_opening = token_copy(tag_opening);
   erb_rescue_node->content = token_copy(content);
   erb_rescue_node->tag_closing = token_copy(tag_closing);
-  erb_rescue_node->statements = statements;
+  if (statements == NULL) {
+    erb_rescue_node->statements = hb_array_init(8);
+  } else {
+    erb_rescue_node->statements = statements;
+  }
   erb_rescue_node->subsequent = subsequent;
 
   return erb_rescue_node;
@@ -358,7 +446,11 @@ AST_ERB_ENSURE_NODE_T* ast_erb_ensure_node_init(token_T* tag_opening, token_T* c
   erb_ensure_node->tag_opening = token_copy(tag_opening);
   erb_ensure_node->content = token_copy(content);
   erb_ensure_node->tag_closing = token_copy(tag_closing);
-  erb_ensure_node->statements = statements;
+  if (statements == NULL) {
+    erb_ensure_node->statements = hb_array_init(8);
+  } else {
+    erb_ensure_node->statements = statements;
+  }
 
   return erb_ensure_node;
 }
@@ -371,7 +463,11 @@ AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* con
   erb_begin_node->tag_opening = token_copy(tag_opening);
   erb_begin_node->content = token_copy(content);
   erb_begin_node->tag_closing = token_copy(tag_closing);
-  erb_begin_node->statements = statements;
+  if (statements == NULL) {
+    erb_begin_node->statements = hb_array_init(8);
+  } else {
+    erb_begin_node->statements = statements;
+  }
   erb_begin_node->rescue_clause = rescue_clause;
   erb_begin_node->else_clause = else_clause;
   erb_begin_node->ensure_clause = ensure_clause;
@@ -388,7 +484,11 @@ AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* c
   erb_unless_node->tag_opening = token_copy(tag_opening);
   erb_unless_node->content = token_copy(content);
   erb_unless_node->tag_closing = token_copy(tag_closing);
-  erb_unless_node->statements = statements;
+  if (statements == NULL) {
+    erb_unless_node->statements = hb_array_init(8);
+  } else {
+    erb_unless_node->statements = statements;
+  }
   erb_unless_node->else_clause = else_clause;
   erb_unless_node->end_node = end_node;
 
@@ -415,7 +515,11 @@ AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content,
   erb_in_node->tag_opening = token_copy(tag_opening);
   erb_in_node->content = token_copy(content);
   erb_in_node->tag_closing = token_copy(tag_closing);
-  erb_in_node->statements = statements;
+  if (statements == NULL) {
+    erb_in_node->statements = hb_array_init(8);
+  } else {
+    erb_in_node->statements = statements;
+  }
 
   return erb_in_node;
 }
@@ -500,7 +604,7 @@ void ast_free_base_node(AST_NODE_T* node) {
   if (node == NULL) { return; }
 
   if (node->errors) {
-    for (size_t i = 0; i < hb_array_size(node->errors); i++) {
+    for (size_t i = 0; i < node->errors->size; i++) {
       ERROR_T* child = hb_array_get(node->errors, i);
       if (child != NULL) { error_free(child); }
     }
@@ -514,7 +618,7 @@ void ast_free_base_node(AST_NODE_T* node) {
 
 static void ast_free_document_node(AST_DOCUMENT_NODE_T* document_node) {
   if (document_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(document_node->children); i++) {
+    for (size_t i = 0; i < document_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(document_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -536,7 +640,7 @@ static void ast_free_html_open_tag_node(AST_HTML_OPEN_TAG_NODE_T* html_open_tag_
   if (html_open_tag_node->tag_name != NULL) { token_free(html_open_tag_node->tag_name); }
   if (html_open_tag_node->tag_closing != NULL) { token_free(html_open_tag_node->tag_closing); }
   if (html_open_tag_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(html_open_tag_node->children); i++) {
+    for (size_t i = 0; i < html_open_tag_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(html_open_tag_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -551,7 +655,7 @@ static void ast_free_html_close_tag_node(AST_HTML_CLOSE_TAG_NODE_T* html_close_t
   if (html_close_tag_node->tag_opening != NULL) { token_free(html_close_tag_node->tag_opening); }
   if (html_close_tag_node->tag_name != NULL) { token_free(html_close_tag_node->tag_name); }
   if (html_close_tag_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(html_close_tag_node->children); i++) {
+    for (size_t i = 0; i < html_close_tag_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(html_close_tag_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -567,7 +671,7 @@ static void ast_free_html_element_node(AST_HTML_ELEMENT_NODE_T* html_element_nod
   ast_node_free((AST_NODE_T*) html_element_node->open_tag);
   if (html_element_node->tag_name != NULL) { token_free(html_element_node->tag_name); }
   if (html_element_node->body != NULL) {
-    for (size_t i = 0; i < hb_array_size(html_element_node->body); i++) {
+    for (size_t i = 0; i < html_element_node->body->size; i++) {
       AST_NODE_T* child = hb_array_get(html_element_node->body, i);
       if (child) { ast_node_free(child); }
     }
@@ -582,7 +686,7 @@ static void ast_free_html_element_node(AST_HTML_ELEMENT_NODE_T* html_element_nod
 static void ast_free_html_attribute_value_node(AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node) {
   if (html_attribute_value_node->open_quote != NULL) { token_free(html_attribute_value_node->open_quote); }
   if (html_attribute_value_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(html_attribute_value_node->children); i++) {
+    for (size_t i = 0; i < html_attribute_value_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(html_attribute_value_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -596,7 +700,7 @@ static void ast_free_html_attribute_value_node(AST_HTML_ATTRIBUTE_VALUE_NODE_T*
 
 static void ast_free_html_attribute_name_node(AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node) {
   if (html_attribute_name_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(html_attribute_name_node->children); i++) {
+    for (size_t i = 0; i < html_attribute_name_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(html_attribute_name_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -624,7 +728,7 @@ static void ast_free_html_text_node(AST_HTML_TEXT_NODE_T* html_text_node) {
 static void ast_free_html_comment_node(AST_HTML_COMMENT_NODE_T* html_comment_node) {
   if (html_comment_node->comment_start != NULL) { token_free(html_comment_node->comment_start); }
   if (html_comment_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(html_comment_node->children); i++) {
+    for (size_t i = 0; i < html_comment_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(html_comment_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -639,7 +743,7 @@ static void ast_free_html_comment_node(AST_HTML_COMMENT_NODE_T* html_comment_nod
 static void ast_free_html_doctype_node(AST_HTML_DOCTYPE_NODE_T* html_doctype_node) {
   if (html_doctype_node->tag_opening != NULL) { token_free(html_doctype_node->tag_opening); }
   if (html_doctype_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(html_doctype_node->children); i++) {
+    for (size_t i = 0; i < html_doctype_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(html_doctype_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -654,7 +758,7 @@ static void ast_free_html_doctype_node(AST_HTML_DOCTYPE_NODE_T* html_doctype_nod
 static void ast_free_xml_declaration_node(AST_XML_DECLARATION_NODE_T* xml_declaration_node) {
   if (xml_declaration_node->tag_opening != NULL) { token_free(xml_declaration_node->tag_opening); }
   if (xml_declaration_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(xml_declaration_node->children); i++) {
+    for (size_t i = 0; i < xml_declaration_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(xml_declaration_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -669,7 +773,7 @@ static void ast_free_xml_declaration_node(AST_XML_DECLARATION_NODE_T* xml_declar
 static void ast_free_cdata_node(AST_CDATA_NODE_T* cdata_node) {
   if (cdata_node->tag_opening != NULL) { token_free(cdata_node->tag_opening); }
   if (cdata_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(cdata_node->children); i++) {
+    for (size_t i = 0; i < cdata_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(cdata_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -711,7 +815,7 @@ static void ast_free_erb_else_node(AST_ERB_ELSE_NODE_T* erb_else_node) {
   if (erb_else_node->content != NULL) { token_free(erb_else_node->content); }
   if (erb_else_node->tag_closing != NULL) { token_free(erb_else_node->tag_closing); }
   if (erb_else_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_else_node->statements); i++) {
+    for (size_t i = 0; i < erb_else_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_else_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -727,7 +831,7 @@ static void ast_free_erb_if_node(AST_ERB_IF_NODE_T* erb_if_node) {
   if (erb_if_node->content != NULL) { token_free(erb_if_node->content); }
   if (erb_if_node->tag_closing != NULL) { token_free(erb_if_node->tag_closing); }
   if (erb_if_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_if_node->statements); i++) {
+    for (size_t i = 0; i < erb_if_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_if_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -745,7 +849,7 @@ static void ast_free_erb_block_node(AST_ERB_BLOCK_NODE_T* erb_block_node) {
   if (erb_block_node->content != NULL) { token_free(erb_block_node->content); }
   if (erb_block_node->tag_closing != NULL) { token_free(erb_block_node->tag_closing); }
   if (erb_block_node->body != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_block_node->body); i++) {
+    for (size_t i = 0; i < erb_block_node->body->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_block_node->body, i);
       if (child) { ast_node_free(child); }
     }
@@ -762,7 +866,7 @@ static void ast_free_erb_when_node(AST_ERB_WHEN_NODE_T* erb_when_node) {
   if (erb_when_node->content != NULL) { token_free(erb_when_node->content); }
   if (erb_when_node->tag_closing != NULL) { token_free(erb_when_node->tag_closing); }
   if (erb_when_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_when_node->statements); i++) {
+    for (size_t i = 0; i < erb_when_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_when_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -778,7 +882,7 @@ static void ast_free_erb_case_node(AST_ERB_CASE_NODE_T* erb_case_node) {
   if (erb_case_node->content != NULL) { token_free(erb_case_node->content); }
   if (erb_case_node->tag_closing != NULL) { token_free(erb_case_node->tag_closing); }
   if (erb_case_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_case_node->children); i++) {
+    for (size_t i = 0; i < erb_case_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_case_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -786,7 +890,7 @@ static void ast_free_erb_case_node(AST_ERB_CASE_NODE_T* erb_case_node) {
     hb_array_free(&erb_case_node->children);
   }
   if (erb_case_node->conditions != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_case_node->conditions); i++) {
+    for (size_t i = 0; i < erb_case_node->conditions->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_case_node->conditions, i);
       if (child) { ast_node_free(child); }
     }
@@ -804,7 +908,7 @@ static void ast_free_erb_case_match_node(AST_ERB_CASE_MATCH_NODE_T* erb_case_mat
   if (erb_case_match_node->content != NULL) { token_free(erb_case_match_node->content); }
   if (erb_case_match_node->tag_closing != NULL) { token_free(erb_case_match_node->tag_closing); }
   if (erb_case_match_node->children != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_case_match_node->children); i++) {
+    for (size_t i = 0; i < erb_case_match_node->children->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_case_match_node->children, i);
       if (child) { ast_node_free(child); }
     }
@@ -812,7 +916,7 @@ static void ast_free_erb_case_match_node(AST_ERB_CASE_MATCH_NODE_T* erb_case_mat
     hb_array_free(&erb_case_match_node->children);
   }
   if (erb_case_match_node->conditions != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_case_match_node->conditions); i++) {
+    for (size_t i = 0; i < erb_case_match_node->conditions->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_case_match_node->conditions, i);
       if (child) { ast_node_free(child); }
     }
@@ -830,7 +934,7 @@ static void ast_free_erb_while_node(AST_ERB_WHILE_NODE_T* erb_while_node) {
   if (erb_while_node->content != NULL) { token_free(erb_while_node->content); }
   if (erb_while_node->tag_closing != NULL) { token_free(erb_while_node->tag_closing); }
   if (erb_while_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_while_node->statements); i++) {
+    for (size_t i = 0; i < erb_while_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_while_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -847,7 +951,7 @@ static void ast_free_erb_until_node(AST_ERB_UNTIL_NODE_T* erb_until_node) {
   if (erb_until_node->content != NULL) { token_free(erb_until_node->content); }
   if (erb_until_node->tag_closing != NULL) { token_free(erb_until_node->tag_closing); }
   if (erb_until_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_until_node->statements); i++) {
+    for (size_t i = 0; i < erb_until_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_until_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -864,7 +968,7 @@ static void ast_free_erb_for_node(AST_ERB_FOR_NODE_T* erb_for_node) {
   if (erb_for_node->content != NULL) { token_free(erb_for_node->content); }
   if (erb_for_node->tag_closing != NULL) { token_free(erb_for_node->tag_closing); }
   if (erb_for_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_for_node->statements); i++) {
+    for (size_t i = 0; i < erb_for_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_for_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -881,7 +985,7 @@ static void ast_free_erb_rescue_node(AST_ERB_RESCUE_NODE_T* erb_rescue_node) {
   if (erb_rescue_node->content != NULL) { token_free(erb_rescue_node->content); }
   if (erb_rescue_node->tag_closing != NULL) { token_free(erb_rescue_node->tag_closing); }
   if (erb_rescue_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_rescue_node->statements); i++) {
+    for (size_t i = 0; i < erb_rescue_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_rescue_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -898,7 +1002,7 @@ static void ast_free_erb_ensure_node(AST_ERB_ENSURE_NODE_T* erb_ensure_node) {
   if (erb_ensure_node->content != NULL) { token_free(erb_ensure_node->content); }
   if (erb_ensure_node->tag_closing != NULL) { token_free(erb_ensure_node->tag_closing); }
   if (erb_ensure_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_ensure_node->statements); i++) {
+    for (size_t i = 0; i < erb_ensure_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_ensure_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -914,7 +1018,7 @@ static void ast_free_erb_begin_node(AST_ERB_BEGIN_NODE_T* erb_begin_node) {
   if (erb_begin_node->content != NULL) { token_free(erb_begin_node->content); }
   if (erb_begin_node->tag_closing != NULL) { token_free(erb_begin_node->tag_closing); }
   if (erb_begin_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_begin_node->statements); i++) {
+    for (size_t i = 0; i < erb_begin_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_begin_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -934,7 +1038,7 @@ static void ast_free_erb_unless_node(AST_ERB_UNLESS_NODE_T* erb_unless_node) {
   if (erb_unless_node->content != NULL) { token_free(erb_unless_node->content); }
   if (erb_unless_node->tag_closing != NULL) { token_free(erb_unless_node->tag_closing); }
   if (erb_unless_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_unless_node->statements); i++) {
+    for (size_t i = 0; i < erb_unless_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_unless_node->statements, i);
       if (child) { ast_node_free(child); }
     }
@@ -960,7 +1064,7 @@ static void ast_free_erb_in_node(AST_ERB_IN_NODE_T* erb_in_node) {
   if (erb_in_node->content != NULL) { token_free(erb_in_node->content); }
   if (erb_in_node->tag_closing != NULL) { token_free(erb_in_node->tag_closing); }
   if (erb_in_node->statements != NULL) {
-    for (size_t i = 0; i < hb_array_size(erb_in_node->statements); i++) {
+    for (size_t i = 0; i < erb_in_node->statements->size; i++) {
       AST_NODE_T* child = hb_array_get(erb_in_node->statements, i);
       if (child) { ast_node_free(child); }
     }

data/src/errors.c

@@ -644,7 +644,7 @@ void error_pretty_print_array(
     return;
   }
 
-  if (hb_array_size(array) == 0) {
+  if (array->size == 0) {
     pretty_print_property(hb_string(name), hb_string("[]"), indent, relative_indent, last_property, buffer);
 
     return;
@@ -655,17 +655,17 @@ void error_pretty_print_array(
   hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", hb_array_size(array));
+  sprintf(count, "%zu", array->size);
   hb_buffer_append(buffer, count);
   hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < hb_array_size(array); i++) {
+    for (size_t i = 0; i < array->size; i++) {
       ERROR_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == hb_array_size(array) - 1) {
+      if (i == array->size - 1) {
         hb_buffer_append(buffer, "└── ");
       } else {
         hb_buffer_append(buffer, "├── ");
@@ -673,7 +673,7 @@ void error_pretty_print_array(
 
       error_pretty_print(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != array->size - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
 }

data/src/extract.c

@@ -12,7 +12,7 @@ void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
   bool skip_erb_content = false;
   bool is_comment_tag = false;
 
-  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+  for (size_t i = 0; i < tokens->size; i++) {
     const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
@@ -94,7 +94,7 @@ void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
 void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output) {
   hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+  for (size_t i = 0; i < tokens->size; i++) {
     const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {

data/src/herb.c

@@ -58,7 +58,7 @@ HERB_EXPORTED_FUNCTION hb_array_T* herb_lex_file(const char* path) {
 HERB_EXPORTED_FUNCTION void herb_lex_to_buffer(const char* source, hb_buffer_T* output) {
   hb_array_T* tokens = herb_lex(source);
 
-  for (size_t i = 0; i < hb_array_size(tokens); i++) {
+  for (size_t i = 0; i < tokens->size; i++) {
     token_T* token = hb_array_get(tokens, i);
 
     hb_string_T type = token_to_string(token);
@@ -74,7 +74,7 @@ HERB_EXPORTED_FUNCTION void herb_lex_to_buffer(const char* source, hb_buffer_T*
 HERB_EXPORTED_FUNCTION void herb_free_tokens(hb_array_T** tokens) {
   if (!tokens || !*tokens) { return; }
 
-  for (size_t i = 0; i < hb_array_size(*tokens); i++) {
+  for (size_t i = 0; i < (*tokens)->size; i++) {
     token_T* token = hb_array_get(*tokens, i);
     if (token) { token_free(token); }
   }

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.3"
+#define HERB_VERSION "0.8.4"
 
 #endif