herb 0.8.6 → 0.8.8

data/src/ast_pretty_print.c

@@ -265,6 +265,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_if_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_if_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_if_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("then_keyword"), indent, relative_indent, false, buffer);
+      if (erb_if_node->then_keyword) {
+        char then_keyword_location_string[128];
+        sprintf(then_keyword_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          erb_if_node->then_keyword->start.line,
+          erb_if_node->then_keyword->start.column,
+          erb_if_node->then_keyword->end.line,
+          erb_if_node->then_keyword->end.column);
+        hb_buffer_append(buffer, then_keyword_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       pretty_print_array(hb_string("statements"), erb_if_node->statements, indent, relative_indent, false, buffer);
 
       pretty_print_label(hb_string("subsequent"), indent, relative_indent, false, buffer);
@@ -330,6 +343,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_when_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_when_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_when_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("then_keyword"), indent, relative_indent, false, buffer);
+      if (erb_when_node->then_keyword) {
+        char then_keyword_location_string[128];
+        sprintf(then_keyword_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          erb_when_node->then_keyword->start.line,
+          erb_when_node->then_keyword->start.column,
+          erb_when_node->then_keyword->end.line,
+          erb_when_node->then_keyword->end.column);
+        hb_buffer_append(buffer, then_keyword_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       pretty_print_array(hb_string("statements"), erb_when_node->statements, indent, relative_indent, true, buffer);
     } break;
 
@@ -602,6 +628,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_unless_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_unless_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_unless_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("then_keyword"), indent, relative_indent, false, buffer);
+      if (erb_unless_node->then_keyword) {
+        char then_keyword_location_string[128];
+        sprintf(then_keyword_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          erb_unless_node->then_keyword->start.line,
+          erb_unless_node->then_keyword->start.column,
+          erb_unless_node->then_keyword->end.line,
+          erb_unless_node->then_keyword->end.column);
+        hb_buffer_append(buffer, then_keyword_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       pretty_print_array(hb_string("statements"), erb_unless_node->statements, indent, relative_indent, false, buffer);
 
       pretty_print_label(hb_string("else_clause"), indent, relative_indent, false, buffer);
@@ -651,6 +690,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_in_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_in_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_in_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("then_keyword"), indent, relative_indent, false, buffer);
+      if (erb_in_node->then_keyword) {
+        char then_keyword_location_string[128];
+        sprintf(then_keyword_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          erb_in_node->then_keyword->start.line,
+          erb_in_node->then_keyword->start.column,
+          erb_in_node->then_keyword->end.line,
+          erb_in_node->then_keyword->end.column);
+        hb_buffer_append(buffer, then_keyword_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       pretty_print_array(hb_string("statements"), erb_in_node->statements, indent, relative_indent, true, buffer);
     } break;
 

data/src/errors.c

@@ -667,7 +667,7 @@ void error_pretty_print_array(
     return;
   }
 
-  if (array->size == 0) {
+  if (hb_array_size(array) == 0) {
     pretty_print_property(hb_string(name), hb_string("[]"), indent, relative_indent, last_property, buffer);
 
     return;
@@ -678,17 +678,17 @@ void error_pretty_print_array(
   hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array->size);
+  sprintf(count, "%zu", hb_array_size(array));
   hb_buffer_append(buffer, count);
   hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array->size; i++) {
+    for (size_t i = 0; i < hb_array_size(array); i++) {
       ERROR_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array->size - 1) {
+      if (i == hb_array_size(array) - 1) {
         hb_buffer_append(buffer, "└── ");
       } else {
         hb_buffer_append(buffer, "├── ");
@@ -696,7 +696,7 @@ void error_pretty_print_array(
 
       error_pretty_print(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array->size - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 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 < tokens->size; i++) {
+  for (size_t i = 0; i < hb_array_size(tokens); i++) {
     const token_T* token = hb_array_get(tokens, i);
 
     switch (token->type) {
@@ -95,7 +95,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 < tokens->size; i++) {
+  for (size_t i = 0; i < hb_array_size(tokens); 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 < tokens->size; i++) {
+  for (size_t i = 0; i < hb_array_size(tokens); 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 < (*tokens)->size; i++) {
+  for (size_t i = 0; i < hb_array_size(*tokens); i++) {
     token_T* token = hb_array_get(*tokens, i);
     if (token) { token_free(token); }
   }

data/src/include/analyze_helpers.h

@@ -25,9 +25,15 @@ bool has_rescue_node(analyzed_ruby_T* analyzed);
 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_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
+bool is_do_block(pm_location_t opening_location);
+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_if_nodes(const pm_node_t* node, void* data);
 bool search_block_nodes(const pm_node_t* node, void* data);
 bool search_case_nodes(const pm_node_t* node, void* data);
@@ -46,6 +52,7 @@ bool search_in_nodes(analyzed_ruby_T* analyzed);
 bool search_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_ensure_nodes(analyzed_ruby_T* analyzed);
 bool search_yield_nodes(const pm_node_t* node, void* data);
+bool search_then_keywords(const pm_node_t* node, void* data);
 bool search_unclosed_control_flows(const pm_node_t* node, void* data);
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node);

data/src/include/analyzed_ruby.h

@@ -29,6 +29,7 @@ typedef struct ANALYZED_RUBY_STRUCT {
   int ensure_node_count;
   int unless_node_count;
   int yield_node_count;
+  int then_keyword_count;
   int unclosed_control_flow_count;
 } analyzed_ruby_T;
 

data/src/include/ast_nodes.h

@@ -183,6 +183,7 @@ typedef struct AST_ERB_IF_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  location_T* then_keyword;
   hb_array_T* statements;
   struct AST_NODE_STRUCT* subsequent;
   struct AST_ERB_END_NODE_STRUCT* end_node;
@@ -202,6 +203,7 @@ typedef struct AST_ERB_WHEN_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  location_T* then_keyword;
   hb_array_T* statements;
 } AST_ERB_WHEN_NODE_T;
 
@@ -288,6 +290,7 @@ typedef struct AST_ERB_UNLESS_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  location_T* then_keyword;
   hb_array_T* statements;
   struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
   struct AST_ERB_END_NODE_STRUCT* end_node;
@@ -305,6 +308,7 @@ typedef struct AST_ERB_IN_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  location_T* then_keyword;
   hb_array_T* statements;
 } AST_ERB_IN_NODE_T;
 
@@ -325,9 +329,9 @@ AST_WHITESPACE_NODE_T* ast_whitespace_node_init(token_T* value, position_T start
 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, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_END_NODE_T* ast_erb_end_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);
 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);
-AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_NODE_STRUCT* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
+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, hb_array_T* statements, struct AST_NODE_STRUCT* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* body, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
-AST_ERB_WHEN_NODE_T* ast_erb_when_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);
+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);
 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, 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);
 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, 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);
 AST_ERB_WHILE_NODE_T* ast_erb_while_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
@@ -336,9 +340,9 @@ AST_ERB_FOR_NODE_T* ast_erb_for_node_init(token_T* tag_opening, token_T* content
 AST_ERB_RESCUE_NODE_T* ast_erb_rescue_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* subsequent, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_ENSURE_NODE_T* ast_erb_ensure_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);
 AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, 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);
-AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, 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);
+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, 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);
 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);
-AST_ERB_IN_NODE_T* ast_erb_in_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);
+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_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/location.h

@@ -19,4 +19,8 @@ void location_from(
   uint32_t end_column
 );
 
+void location_from_positions(location_T* location, position_T start, position_T end);
+
+location_T* location_create(position_T start, position_T end);
+
 #endif

data/src/include/prism_helpers.h

@@ -1,8 +1,10 @@
 #ifndef HERB_PRISM_HELPERS_H
 #define HERB_PRISM_HELPERS_H
 
+#include "analyzed_ruby.h"
 #include "ast_nodes.h"
 #include "errors.h"
+#include "location.h"
 #include "position.h"
 
 #include <prism.h>
@@ -22,4 +24,8 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
   position_T end
 );
 
+location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source);
+location_T* get_then_keyword_location_wrapped(const char* source, bool is_in_clause);
+location_T* get_then_keyword_location_elsif_wrapped(const char* source);
+
 #endif

data/src/include/util/hb_narray.h

@@ -18,6 +18,7 @@ void hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacit
 void* hb_narray_get(const hb_narray_T* array, size_t index);
 void* hb_narray_first(hb_narray_T* array);
 void* hb_narray_last(hb_narray_T* array);
+size_t hb_narray_size(const hb_narray_T* array);
 
 void hb_narray_append(hb_narray_T* array, void* item);
 void hb_narray_remove(hb_narray_T* array, size_t index);

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.6"
+#define HERB_VERSION "0.8.8"
 
 #endif

data/src/location.c

@@ -11,3 +11,19 @@ void location_from(
   location->start = (position_T) { .line = start_line, .column = start_column };
   location->end = (position_T) { .line = end_line, .column = end_column };
 }
+
+void location_from_positions(location_T* location, position_T start, position_T end) {
+  location->start = start;
+  location->end = end;
+}
+
+location_T* location_create(position_T start, position_T end) {
+  location_T* location = malloc(sizeof(location_T));
+
+  if (location != NULL) {
+    location->start = start;
+    location->end = end;
+  }
+
+  return location;
+}

data/src/parser.c

@@ -314,7 +314,7 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
   position_T node_start = { 0 };
   position_T node_end = { 0 };
 
-  if (children->size > 0) {
+  if (hb_array_size(children) > 0) {
     AST_NODE_T* first_child = hb_array_first(children);
     AST_NODE_T* last_child = hb_array_last(children);
 
@@ -1144,7 +1144,7 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
 static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_string_T tag_name) {
   int depth = 0;
 
-  for (size_t i = start_idx + 1; i < nodes->size; i++) {
+  for (size_t i = start_idx + 1; i < hb_array_size(nodes); i++) {
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
     if (node == NULL) { continue; }
 
@@ -1168,9 +1168,9 @@ static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_st
 static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T* errors);
 
 static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T* errors) {
-  hb_array_T* result = hb_array_init(nodes->size);
+  hb_array_T* result = hb_array_init(hb_array_size(nodes));
 
-  for (size_t index = 0; index < nodes->size; index++) {
+  for (size_t index = 0; index < hb_array_size(nodes); index++) {
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, index);
     if (node == NULL) { continue; }
 
@@ -1181,7 +1181,7 @@ static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T
       size_t close_index = find_matching_close_tag(nodes, index, tag_name);
 
       if (close_index == (size_t) -1) {
-        if (open_tag->base.errors->size == 0) {
+        if (hb_array_size(open_tag->base.errors) == 0) {
           append_missing_closing_tag_error(
             open_tag->tag_name,
             open_tag->base.location.start,
@@ -1225,7 +1225,7 @@ static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T
       AST_HTML_CLOSE_TAG_NODE_T* close_tag = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
       if (!is_void_element(hb_string(close_tag->tag_name->value))) {
-        if (close_tag->base.errors->size == 0) {
+        if (hb_array_size(close_tag->base.errors) == 0) {
           append_missing_opening_tag_error(
             close_tag->tag_name,
             close_tag->base.location.start,
@@ -1299,19 +1299,19 @@ void herb_parser_deinit(parser_T* parser) {
 }
 
 void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors) {
-  if (nodes == NULL || nodes->size == 0) { return; }
+  if (nodes == NULL || hb_array_size(nodes) == 0) { return; }
 
   hb_array_T* processed = parser_build_elements_from_tags(nodes, errors);
 
   nodes->size = 0;
 
-  for (size_t i = 0; i < processed->size; i++) {
+  for (size_t i = 0; i < hb_array_size(processed); i++) {
     hb_array_append(nodes, hb_array_get(processed, i));
   }
 
   hb_array_free(&processed);
 
-  for (size_t i = 0; i < nodes->size; i++) {
+  for (size_t i = 0; i < hb_array_size(nodes); i++) {
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
     if (node == NULL) { continue; }
 

data/src/parser_helpers.c

@@ -19,7 +19,7 @@ void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
 }
 
 bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
-  if (parser->open_tags_stack->size == 0) { return false; }
+  if (hb_array_size(parser->open_tags_stack) == 0) { return false; }
 
   token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
@@ -28,7 +28,7 @@ bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
-  if (parser->open_tags_stack->size == 0) { return NULL; }
+  if (hb_array_size(parser->open_tags_stack) == 0) { return NULL; }
 
   return hb_array_pop(parser->open_tags_stack);
 }
@@ -42,7 +42,7 @@ token_T* parser_pop_open_tag(const parser_T* parser) {
 bool parser_in_svg_context(const parser_T* parser) {
   if (!parser || !parser->open_tags_stack) { return false; }
 
-  size_t stack_size = parser->open_tags_stack->size;
+  size_t stack_size = hb_array_size(parser->open_tags_stack);
 
   for (size_t i = 0; i < stack_size; i++) {
     token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
@@ -191,7 +191,7 @@ void parser_handle_mismatched_tags(
   const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
   hb_array_T* errors
 ) {
-  if (parser->open_tags_stack->size > 0) {
+  if (hb_array_size(parser->open_tags_stack) > 0) {
     token_T* expected_tag = hb_array_last(parser->open_tags_stack);
     token_T* actual_tag = close_tag->tag_name;
 

data/src/pretty_print.c

@@ -113,7 +113,7 @@ void pretty_print_array(
     return;
   }
 
-  if (array->size == 0) {
+  if (hb_array_size(array) == 0) {
     pretty_print_property(name, hb_string("[]"), indent, relative_indent, last_property, buffer);
 
     return;
@@ -124,17 +124,17 @@ void pretty_print_array(
   hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array->size);
+  sprintf(count, "%zu", hb_array_size(array));
   hb_buffer_append(buffer, count);
   hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array->size; i++) {
+    for (size_t i = 0; i < hb_array_size(array); i++) {
       AST_NODE_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array->size - 1) {
+      if (i == hb_array_size(array) - 1) {
         hb_buffer_append(buffer, "└── ");
       } else {
         hb_buffer_append(buffer, "├── ");
@@ -142,7 +142,7 @@ void pretty_print_array(
 
       ast_pretty_print_node(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array->size - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
   hb_buffer_append(buffer, "\n");
@@ -155,7 +155,7 @@ void pretty_print_errors(
   const bool last_property,
   hb_buffer_T* buffer
 ) {
-  if (node->errors != NULL && node->errors->size > 0) {
+  if (hb_array_size(node->errors) > 0) {
     error_pretty_print_array("errors", node->errors, indent, relative_indent, last_property, buffer);
     hb_buffer_append(buffer, "\n");
   }