herb 0.8.3-arm64-darwin → 0.8.5-arm64-darwin

data/src/visitor.c

@@ -24,7 +24,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_DOCUMENT_NODE_T* document_node = ((const AST_DOCUMENT_NODE_T *) node);
 
       if (document_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(document_node->children); index++) {
+        for (size_t index = 0; index < document_node->children->size; index++) {
           herb_visit_node(hb_array_get(document_node->children, index), visitor, data);
         }
       }
@@ -35,7 +35,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = ((const AST_HTML_OPEN_TAG_NODE_T *) node);
 
       if (html_open_tag_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(html_open_tag_node->children); index++) {
+        for (size_t index = 0; index < html_open_tag_node->children->size; index++) {
           herb_visit_node(hb_array_get(html_open_tag_node->children, index), visitor, data);
         }
       }
@@ -46,7 +46,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = ((const AST_HTML_CLOSE_TAG_NODE_T *) node);
 
       if (html_close_tag_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(html_close_tag_node->children); index++) {
+        for (size_t index = 0; index < html_close_tag_node->children->size; index++) {
           herb_visit_node(hb_array_get(html_close_tag_node->children, index), visitor, data);
         }
       }
@@ -61,7 +61,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       }
 
       if (html_element_node->body != NULL) {
-        for (size_t index = 0; index < hb_array_size(html_element_node->body); index++) {
+        for (size_t index = 0; index < html_element_node->body->size; index++) {
           herb_visit_node(hb_array_get(html_element_node->body, index), visitor, data);
         }
       }
@@ -76,7 +76,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = ((const AST_HTML_ATTRIBUTE_VALUE_NODE_T *) node);
 
       if (html_attribute_value_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(html_attribute_value_node->children); index++) {
+        for (size_t index = 0; index < html_attribute_value_node->children->size; index++) {
           herb_visit_node(hb_array_get(html_attribute_value_node->children, index), visitor, data);
         }
       }
@@ -87,7 +87,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = ((const AST_HTML_ATTRIBUTE_NAME_NODE_T *) node);
 
       if (html_attribute_name_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(html_attribute_name_node->children); index++) {
+        for (size_t index = 0; index < html_attribute_name_node->children->size; index++) {
           herb_visit_node(hb_array_get(html_attribute_name_node->children, index), visitor, data);
         }
       }
@@ -111,7 +111,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_COMMENT_NODE_T* html_comment_node = ((const AST_HTML_COMMENT_NODE_T *) node);
 
       if (html_comment_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(html_comment_node->children); index++) {
+        for (size_t index = 0; index < html_comment_node->children->size; index++) {
           herb_visit_node(hb_array_get(html_comment_node->children, index), visitor, data);
         }
       }
@@ -122,7 +122,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = ((const AST_HTML_DOCTYPE_NODE_T *) node);
 
       if (html_doctype_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(html_doctype_node->children); index++) {
+        for (size_t index = 0; index < html_doctype_node->children->size; index++) {
           herb_visit_node(hb_array_get(html_doctype_node->children, index), visitor, data);
         }
       }
@@ -133,7 +133,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_XML_DECLARATION_NODE_T* xml_declaration_node = ((const AST_XML_DECLARATION_NODE_T *) node);
 
       if (xml_declaration_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(xml_declaration_node->children); index++) {
+        for (size_t index = 0; index < xml_declaration_node->children->size; index++) {
           herb_visit_node(hb_array_get(xml_declaration_node->children, index), visitor, data);
         }
       }
@@ -144,7 +144,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_CDATA_NODE_T* cdata_node = ((const AST_CDATA_NODE_T *) node);
 
       if (cdata_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(cdata_node->children); index++) {
+        for (size_t index = 0; index < cdata_node->children->size; index++) {
           herb_visit_node(hb_array_get(cdata_node->children, index), visitor, data);
         }
       }
@@ -155,7 +155,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ELSE_NODE_T* erb_else_node = ((const AST_ERB_ELSE_NODE_T *) node);
 
       if (erb_else_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_else_node->statements); index++) {
+        for (size_t index = 0; index < erb_else_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_else_node->statements, index), visitor, data);
         }
       }
@@ -166,7 +166,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IF_NODE_T* erb_if_node = ((const AST_ERB_IF_NODE_T *) node);
 
       if (erb_if_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_if_node->statements); index++) {
+        for (size_t index = 0; index < erb_if_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_if_node->statements, index), visitor, data);
         }
       }
@@ -185,7 +185,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BLOCK_NODE_T* erb_block_node = ((const AST_ERB_BLOCK_NODE_T *) node);
 
       if (erb_block_node->body != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_block_node->body); index++) {
+        for (size_t index = 0; index < erb_block_node->body->size; index++) {
           herb_visit_node(hb_array_get(erb_block_node->body, index), visitor, data);
         }
       }
@@ -200,7 +200,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHEN_NODE_T* erb_when_node = ((const AST_ERB_WHEN_NODE_T *) node);
 
       if (erb_when_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_when_node->statements); index++) {
+        for (size_t index = 0; index < erb_when_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_when_node->statements, index), visitor, data);
         }
       }
@@ -211,13 +211,13 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_NODE_T* erb_case_node = ((const AST_ERB_CASE_NODE_T *) node);
 
       if (erb_case_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_case_node->children); index++) {
+        for (size_t index = 0; index < erb_case_node->children->size; index++) {
           herb_visit_node(hb_array_get(erb_case_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_node->conditions != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_case_node->conditions); index++) {
+        for (size_t index = 0; index < erb_case_node->conditions->size; index++) {
           herb_visit_node(hb_array_get(erb_case_node->conditions, index), visitor, data);
         }
       }
@@ -236,13 +236,13 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = ((const AST_ERB_CASE_MATCH_NODE_T *) node);
 
       if (erb_case_match_node->children != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_case_match_node->children); index++) {
+        for (size_t index = 0; index < erb_case_match_node->children->size; index++) {
           herb_visit_node(hb_array_get(erb_case_match_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_match_node->conditions != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_case_match_node->conditions); index++) {
+        for (size_t index = 0; index < erb_case_match_node->conditions->size; index++) {
           herb_visit_node(hb_array_get(erb_case_match_node->conditions, index), visitor, data);
         }
       }
@@ -261,7 +261,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHILE_NODE_T* erb_while_node = ((const AST_ERB_WHILE_NODE_T *) node);
 
       if (erb_while_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_while_node->statements); index++) {
+        for (size_t index = 0; index < erb_while_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_while_node->statements, index), visitor, data);
         }
       }
@@ -276,7 +276,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNTIL_NODE_T* erb_until_node = ((const AST_ERB_UNTIL_NODE_T *) node);
 
       if (erb_until_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_until_node->statements); index++) {
+        for (size_t index = 0; index < erb_until_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_until_node->statements, index), visitor, data);
         }
       }
@@ -291,7 +291,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_FOR_NODE_T* erb_for_node = ((const AST_ERB_FOR_NODE_T *) node);
 
       if (erb_for_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_for_node->statements); index++) {
+        for (size_t index = 0; index < erb_for_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_for_node->statements, index), visitor, data);
         }
       }
@@ -306,7 +306,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_RESCUE_NODE_T* erb_rescue_node = ((const AST_ERB_RESCUE_NODE_T *) node);
 
       if (erb_rescue_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_rescue_node->statements); index++) {
+        for (size_t index = 0; index < erb_rescue_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_rescue_node->statements, index), visitor, data);
         }
       }
@@ -321,7 +321,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ENSURE_NODE_T* erb_ensure_node = ((const AST_ERB_ENSURE_NODE_T *) node);
 
       if (erb_ensure_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_ensure_node->statements); index++) {
+        for (size_t index = 0; index < erb_ensure_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_ensure_node->statements, index), visitor, data);
         }
       }
@@ -332,7 +332,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BEGIN_NODE_T* erb_begin_node = ((const AST_ERB_BEGIN_NODE_T *) node);
 
       if (erb_begin_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_begin_node->statements); index++) {
+        for (size_t index = 0; index < erb_begin_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_begin_node->statements, index), visitor, data);
         }
       }
@@ -359,7 +359,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNLESS_NODE_T* erb_unless_node = ((const AST_ERB_UNLESS_NODE_T *) node);
 
       if (erb_unless_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_unless_node->statements); index++) {
+        for (size_t index = 0; index < erb_unless_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_unless_node->statements, index), visitor, data);
         }
       }
@@ -378,7 +378,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IN_NODE_T* erb_in_node = ((const AST_ERB_IN_NODE_T *) node);
 
       if (erb_in_node->statements != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_in_node->statements); index++) {
+        for (size_t index = 0; index < erb_in_node->statements->size; index++) {
           herb_visit_node(hb_array_get(erb_in_node->statements, index), visitor, data);
         }
       }

data/templates/ext/herb/error_helpers.c.erb

@@ -71,7 +71,7 @@ VALUE rb_errors_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < hb_array_size(array); i++) {
+    for (size_t i = 0; i < array->size; i++) {
       ERROR_T* child_node = (ERROR_T*) hb_array_get(array, i);
 
       if (child_node) {

data/templates/ext/herb/nodes.c.erb

@@ -81,7 +81,7 @@ static VALUE rb_nodes_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < hb_array_size(array); i++) {
+    for (size_t i = 0; i < array->size; i++) {
       AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
       if (child_node) {

data/templates/java/error_helpers.c.erb

@@ -46,7 +46,7 @@ jobject ErrorsArrayFromCArray(JNIEnv* env, hb_array_T* array) {
   jobject javaList = (*env)->NewObject(env, arrayListClass, arrayListConstructor, 0);
 
   if (array) {
-    for (size_t i = 0; i < hb_array_size(array); i++) {
+    for (size_t i = 0; i < array->size; i++) {
       ERROR_T* error = (ERROR_T*) hb_array_get(array, i);
 
       if (error) {

data/templates/java/nodes.c.erb

@@ -75,9 +75,9 @@ jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
     return (*env)->NewObject(env, arrayListClass, arrayListConstructor, 0);
   }
 
-  jobject javaList = (*env)->NewObject(env, arrayListClass, arrayListConstructor, (jint) hb_array_size(array));
+  jobject javaList = (*env)->NewObject(env, arrayListClass, arrayListConstructor, (jint) array->size);
 
-  for (size_t i = 0; i < hb_array_size(array); i++) {
+  for (size_t i = 0; i < array->size; i++) {
     AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
     if (child_node) {

data/templates/javascript/packages/node/extension/error_helpers.cpp.erb

@@ -80,7 +80,7 @@ napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < hb_array_size(array); i++) {
+    for (size_t i = 0; i < array->size; i++) {
       ERROR_T* error = (ERROR_T*) hb_array_get(array, i);
       if (error) {
         napi_value js_error = ErrorFromCStruct(env, error);

data/templates/javascript/packages/node/extension/nodes.cpp.erb

@@ -78,7 +78,7 @@ napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < hb_array_size(array); i++) {
+    for (size_t i = 0; i < array->size; i++) {
       AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
       if (child_node) {
         napi_value js_child = NodeFromCStruct(env, child_node);

data/templates/lib/herb/errors.rb.erb

@@ -46,6 +46,7 @@ module Herb
     <%- errors.each do |error| -%>
     class <%= error.name -%> < Error
       include Colors
+      <%- if error.fields.any? -%>
 
       <%- error.fields.each do |field| -%>
       attr_reader :<%= field.name %> #: <%= field.ruby_type %>
@@ -54,25 +55,27 @@ module Herb
       #: (<%= [*base_arguments.map(&:last), *error.fields.map(&:ruby_type)].join(", ") %>) -> void
       def initialize(<%= [*base_arguments.map(&:first), *error.fields.map(&:name)].join(", ") %>)
         super(<%= base_arguments.map(&:first).join(", ") %>)
-
         <%- error.fields.each do |field| -%>
         @<%= field.name %> = <%= field.name %>
         <%- end -%>
       end
+      <%- end -%>
 
       #: () -> String
       def inspect
         tree_inspect.rstrip.gsub(/\s+$/, "")
       end
+      <%- if error.fields.any? -%>
 
       #: () -> serialized_<%= error.human %>
       def to_hash
-        super.merge({
-          <%- error.fields.each do |field| -%>
-          <%= field.name %>: <%= field.name %>,
+        super.merge(
+          <%- error.fields.each_with_index do |field, index| -%>
+          <%= field.name %>: <%= field.name %><%= index < error.fields.size - 1 ? "," : "" %>
           <%- end -%>
-        }) #: Herb::serialized_<%= error.human %>
+        ) #: Herb::serialized_<%= error.human %>
       end
+      <%- end -%>
 
       #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)

data/templates/rust/src/ast/nodes.rs.erb

@@ -51,7 +51,7 @@ unsafe fn convert_errors(errors_array: *mut hb_array_T) -> Vec<AnyError> {
     return Vec::new();
   }
 
-  let count = hb_array_size(errors_array);
+  let count = (*errors_array).size;
   let mut errors = Vec::with_capacity(count);
 
   for index in 0..count {
@@ -110,7 +110,7 @@ unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec<AnyNode> {
     return Vec::new();
   }
 
-  let count = hb_array_size(children_array);
+  let count = (*children_array).size;
   let mut children = Vec::with_capacity(count);
 
   for index in 0..count {

data/templates/src/ast_nodes.c.erb

@@ -27,7 +27,11 @@
   <%- when Herb::Template::NodeField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::ArrayField -%>
-  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  if (<%= field.name %> == NULL) {
+    <%= node.human %>-><%= field.name %> = hb_array_init(8);
+  } else {
+    <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  }
   <%- when Herb::Template::BooleanField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::ElementSourceField -%>
@@ -73,7 +77,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); }
     }
@@ -99,7 +103,7 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
   ast_node_free((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::ArrayField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) {
-    for (size_t i = 0; i < hb_array_size(<%= node.human %>-><%= field.name %>); i++) {
+    for (size_t i = 0; i < <%= node.human %>-><%= field.name %>->size; i++) {
       AST_NODE_T* child = hb_array_get(<%= node.human %>-><%= field.name %>, i);
       if (child) { ast_node_free(child); }
     }

data/templates/src/ast_pretty_print.c.erb

@@ -1,3 +1,4 @@
+#include "include/analyze_helpers.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
@@ -62,21 +63,21 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
       <%- when Herb::Template::AnalyzedRubyField -%>
       if (<%= node.human %>-><%= field.name %>) {
-        pretty_print_boolean_property(hb_string("if_node"), <%= node.human %>-><%= field.name %>->has_if_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("elsif_node"), <%= node.human %>-><%= field.name %>->has_elsif_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("else_node"), <%= node.human %>-><%= field.name %>->has_else_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("end"), <%= node.human %>-><%= field.name %>->has_end, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("block_node"), <%= node.human %>-><%= field.name %>->has_block_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("block_closing"), <%= node.human %>-><%= field.name %>->has_block_closing, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("case_node"), <%= node.human %>-><%= field.name %>->has_case_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("when_node"), <%= node.human %>-><%= field.name %>->has_when_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("for_node"), <%= node.human %>-><%= field.name %>->has_for_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("while_node"), <%= node.human %>-><%= field.name %>->has_while_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("until_node"), <%= node.human %>-><%= field.name %>->has_until_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("begin_node"), <%= node.human %>-><%= field.name %>->has_begin_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("rescue_node"), <%= node.human %>-><%= field.name %>->has_rescue_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("ensure_node"), <%= node.human %>-><%= field.name %>->has_ensure_node, indent, relative_indent,  <%= last %>, buffer);
-        pretty_print_boolean_property(hb_string("unless_node"), <%= node.human %>-><%= field.name %>->has_unless_node, indent, relative_indent,  <%= last %>, buffer);
+        pretty_print_boolean_property(hb_string("if_node"), has_if_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("elsif_node"), has_elsif_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("else_node"), has_else_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("end"), has_end(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_node"), has_block_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_closing"), has_block_closing(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("case_node"), has_case_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("when_node"), has_when_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("for_node"), has_for_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("while_node"), has_while_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("until_node"), has_until_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("begin_node"), has_begin_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("rescue_node"), has_rescue_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("ensure_node"), has_ensure_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("unless_node"), has_unless_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
       } else {
       pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
         hb_buffer_append(buffer, " ∅\n");

data/templates/src/errors.c.erb

@@ -167,7 +167,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;
@@ -178,17 +178,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, "├── ");
@@ -196,7 +196,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/templates/src/visitor.c.erb

@@ -31,7 +31,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
       <%- when Herb::Template::ArrayField -%>
       if (<%= node.human %>-><%= field.name %> != NULL) {
-        for (size_t index = 0; index < hb_array_size(<%= node.human %>-><%= field.name %>); index++) {
+        for (size_t index = 0; index < <%= node.human %>-><%= field.name %>->size; index++) {
           herb_visit_node(hb_array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
         }
       }

data/templates/wasm/error_helpers.cpp.erb

@@ -66,7 +66,7 @@ val ErrorsArrayFromCArray(hb_array_T* array) {
   val result = Array.new_();
 
   if (array) {
-    for (size_t i = 0; i < hb_array_size(array); i++) {
+    for (size_t i = 0; i < array->size; i++) {
       ERROR_T* error = (ERROR_T*)hb_array_get(array, i);
       if (error) {
         result.call<void>("push", ErrorFromCStruct(error));

data/templates/wasm/nodes.cpp.erb

@@ -67,7 +67,7 @@ val NodesArrayFromCArray(hb_array_T* array) {
 
   val jsArray = val::array();
 
-  for (size_t i = 0; i < hb_array_size(array); i++) {
+  for (size_t i = 0; i < array->size; i++) {
     AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
     if (child_node) {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.5
 platform: arm64-darwin
 authors:
 - Marco Roth