herb 0.8.3 → 0.8.5

data/src/errors.c

@@ -497,6 +497,20 @@ void append_missingerb_end_tag_error(const char* keyword, position_T start, posi
   hb_array_append(errors, missingerb_end_tag_error_init(keyword, start, end));
 }
 
+ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end) {
+  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error = malloc(sizeof(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T));
+
+  error_init(&erb_multiple_blocks_in_tag_error->base, ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR, start, end);
+
+  erb_multiple_blocks_in_tag_error->base.message = herb_strdup("Multiple unclosed control flow blocks in a single ERB tag. Split each block into its own ERB tag, or close all blocks within the same tag.");
+
+  return erb_multiple_blocks_in_tag_error;
+}
+
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, erb_multiple_blocks_in_tag_error_init(start, end));
+}
+
 const char* error_type_to_string(ERROR_T* error) {
   switch (error->type) {
     case UNEXPECTED_ERROR: return "UNEXPECTED_ERROR";
@@ -510,6 +524,7 @@ const char* error_type_to_string(ERROR_T* error) {
     case RUBY_PARSE_ERROR: return "RUBY_PARSE_ERROR";
     case ERB_CONTROL_FLOW_SCOPE_ERROR: return "ERB_CONTROL_FLOW_SCOPE_ERROR";
     case MISSINGERB_END_TAG_ERROR: return "MISSINGERB_END_TAG_ERROR";
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR";
   }
 
   return "Unknown error_type_T";
@@ -528,6 +543,7 @@ const char* error_human_type(ERROR_T* error) {
     case RUBY_PARSE_ERROR: return "RubyParseError";
     case ERB_CONTROL_FLOW_SCOPE_ERROR: return "ERBControlFlowScopeError";
     case MISSINGERB_END_TAG_ERROR: return "MissingERBEndTagError";
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return "ERBMultipleBlocksInTagError";
   }
 
   return "Unknown error_type_T";
@@ -616,6 +632,12 @@ static void error_free_missingerb_end_tag_error(MISSINGERB_END_TAG_ERROR_T* miss
   error_free_base_error(&missingerb_end_tag_error->base);
 }
 
+static void error_free_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error) {
+  /* no ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T specific fields to free up */
+
+  error_free_base_error(&erb_multiple_blocks_in_tag_error->base);
+}
+
 void error_free(ERROR_T* error) {
   if (!error) { return; }
 
@@ -631,6 +653,7 @@ void error_free(ERROR_T* error) {
     case RUBY_PARSE_ERROR: error_free_ruby_parse_error((RUBY_PARSE_ERROR_T*) error); break;
     case ERB_CONTROL_FLOW_SCOPE_ERROR: error_free_erb_control_flow_scope_error((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error); break;
     case MISSINGERB_END_TAG_ERROR: error_free_missingerb_end_tag_error((MISSINGERB_END_TAG_ERROR_T*) error); break;
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_free_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error); break;
   }
 }
 
@@ -644,7 +667,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 +678,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 +696,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); }
     }
   }
 }
@@ -841,6 +864,19 @@ static void error_pretty_print_missingerb_end_tag_error(MISSINGERB_END_TAG_ERROR
   pretty_print_quoted_property(hb_string("keyword"), hb_string(error->keyword), indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, true, buffer);
+}
+
 void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -856,5 +892,6 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     case RUBY_PARSE_ERROR: error_pretty_print_ruby_parse_error((RUBY_PARSE_ERROR_T*) error, indent, relative_indent, buffer); break;
     case ERB_CONTROL_FLOW_SCOPE_ERROR: error_pretty_print_erb_control_flow_scope_error((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error, indent, relative_indent, buffer); break;
     case MISSINGERB_END_TAG_ERROR: error_pretty_print_missingerb_end_tag_error((MISSINGERB_END_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_pretty_print_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
   }
 }

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) {
@@ -25,7 +25,8 @@ void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
         if (strcmp(token->value, "<%#") == 0) {
           skip_erb_content = true;
           is_comment_tag = true;
-        } else if (strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0) {
+        } else if (strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0
+                   || strcmp(token->value, "<%graphql") == 0) {
           skip_erb_content = true;
           is_comment_tag = false;
         } else {
@@ -94,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 < 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/analyze_helpers.h

@@ -46,6 +46,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_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

@@ -11,24 +11,25 @@ typedef struct ANALYZED_RUBY_STRUCT {
   pm_node_t* root;
   bool valid;
   bool parsed;
-  bool has_if_node;
-  bool has_elsif_node;
-  bool has_else_node;
-  bool has_end;
-  bool has_block_closing;
-  bool has_block_node;
-  bool has_case_node;
-  bool has_case_match_node;
-  bool has_when_node;
-  bool has_in_node;
-  bool has_for_node;
-  bool has_while_node;
-  bool has_until_node;
-  bool has_begin_node;
-  bool has_rescue_node;
-  bool has_ensure_node;
-  bool has_unless_node;
-  bool has_yield_node;
+  int if_node_count;
+  int elsif_node_count;
+  int else_node_count;
+  int end_count;
+  int block_closing_count;
+  int block_node_count;
+  int case_node_count;
+  int case_match_node_count;
+  int when_node_count;
+  int in_node_count;
+  int for_node_count;
+  int while_node_count;
+  int until_node_count;
+  int begin_node_count;
+  int rescue_node_count;
+  int ensure_node_count;
+  int unless_node_count;
+  int yield_node_count;
+  int unclosed_control_flow_count;
 } analyzed_ruby_T;
 
 analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);

data/src/include/errors.h

@@ -23,6 +23,7 @@ typedef enum {
   RUBY_PARSE_ERROR,
   ERB_CONTROL_FLOW_SCOPE_ERROR,
   MISSINGERB_END_TAG_ERROR,
+  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -96,6 +97,11 @@ typedef struct {
   const char* keyword;
 } MISSINGERB_END_TAG_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  /* no additional fields */
+} ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end);
 void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end);
@@ -118,6 +124,8 @@ ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* ke
 void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
 MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end);
 void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
+ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end);
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 

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.5"
 
 #endif

data/src/lexer.c

@@ -185,8 +185,8 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 // ===== ERB Parsing
 
 static token_T* lexer_parse_erb_open(lexer_T* lexer) {
-  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="), hb_string("<%#"),
-                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%") };
+  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="),       hb_string("<%#"),
+                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%graphql"), hb_string("<%") };
 
   lexer->state = STATE_ERB_CONTENT;
 
@@ -278,7 +278,7 @@ token_T* lexer_next_token(lexer_T* lexer) {
         return lexer_advance_with_next(lexer, strlen("<![CDATA["), TOKEN_CDATA_START);
       }
 
-      if (isalnum(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
+      if (isalpha(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
 
       if (lexer_peek_for_html_comment_start(lexer, 0)) {
         return lexer_advance_with(lexer, hb_string("<!--"), TOKEN_HTML_COMMENT_START);

data/src/parser.c

@@ -1115,7 +1115,9 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
           TOKEN_DASH,
           TOKEN_EQUALS,
           TOKEN_EXCLAMATION,
+          TOKEN_HTML_TAG_END,
           TOKEN_IDENTIFIER,
+          TOKEN_LT,
           TOKEN_NBSP,
           TOKEN_NEWLINE,
           TOKEN_PERCENT,
@@ -1142,18 +1144,18 @@ 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 < hb_array_size(nodes); i++) {
+  for (size_t i = start_idx + 1; i < nodes->size; i++) {
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
     if (node == NULL) { continue; }
 
     if (node->type == AST_HTML_OPEN_TAG_NODE) {
       AST_HTML_OPEN_TAG_NODE_T* open = (AST_HTML_OPEN_TAG_NODE_T*) node;
 
-      if (hb_string_equals(hb_string(open->tag_name->value), tag_name)) { depth++; }
+      if (hb_string_equals_case_insensitive(hb_string(open->tag_name->value), tag_name)) { depth++; }
     } else if (node->type == AST_HTML_CLOSE_TAG_NODE) {
       AST_HTML_CLOSE_TAG_NODE_T* close = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
-      if (hb_string_equals(hb_string(close->tag_name->value), tag_name)) {
+      if (hb_string_equals_case_insensitive(hb_string(close->tag_name->value), tag_name)) {
         if (depth == 0) { return i; }
         depth--;
       }
@@ -1166,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(hb_array_size(nodes));
+  hb_array_T* result = hb_array_init(nodes->size);
 
-  for (size_t index = 0; index < hb_array_size(nodes); index++) {
+  for (size_t index = 0; index < nodes->size; index++) {
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, index);
     if (node == NULL) { continue; }
 
@@ -1179,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 (hb_array_size(open_tag->base.errors) == 0) {
+        if (open_tag->base.errors->size == 0) {
           append_missing_closing_tag_error(
             open_tag->tag_name,
             open_tag->base.location.start,
@@ -1223,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 (hb_array_size(close_tag->base.errors) == 0) {
+        if (close_tag->base.errors->size == 0) {
           append_missing_opening_tag_error(
             close_tag->tag_name,
             close_tag->base.location.start,
@@ -1297,7 +1299,7 @@ void herb_parser_deinit(parser_T* parser) {
 }
 
 void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors) {
-  if (nodes == NULL || hb_array_size(nodes) == 0) { return; }
+  if (nodes == NULL || nodes->size == 0) { return; }
 
   hb_array_T* processed = parser_build_elements_from_tags(nodes, errors);
 

data/src/parser_helpers.c

@@ -19,16 +19,16 @@ 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 (hb_array_size(parser->open_tags_stack) == 0) { return false; }
+  if (parser->open_tags_stack->size == 0) { return false; }
 
   token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
-  return hb_string_equals(hb_string(top_token->value), tag_name);
+  return hb_string_equals_case_insensitive(hb_string(top_token->value), tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
-  if (hb_array_size(parser->open_tags_stack) == 0) { return NULL; }
+  if (parser->open_tags_stack->size == 0) { return NULL; }
 
   return hb_array_pop(parser->open_tags_stack);
 }
@@ -42,14 +42,14 @@ 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 = hb_array_size(parser->open_tags_stack);
+  size_t stack_size = parser->open_tags_stack->size;
 
   for (size_t i = 0; i < stack_size; i++) {
     token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
 
     if (tag && tag->value) {
       hb_string_T tag_value_string = hb_string(tag->value);
-      if (hb_string_equals(tag_value_string, hb_string("svg"))) { return true; }
+      if (hb_string_equals_case_insensitive(tag_value_string, hb_string("svg"))) { return true; }
     }
   }
 
@@ -61,8 +61,8 @@ bool parser_in_svg_context(const parser_T* parser) {
 foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return FOREIGN_CONTENT_UNKNOWN; }
 
-  if (hb_string_equals(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
-  if (hb_string_equals(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
+  if (hb_string_equals_case_insensitive(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
+  if (hb_string_equals_case_insensitive(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
 
   return FOREIGN_CONTENT_UNKNOWN;
 }
@@ -191,7 +191,7 @@ void parser_handle_mismatched_tags(
   const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
   hb_array_T* errors
 ) {
-  if (hb_array_size(parser->open_tags_stack) > 0) {
+  if (parser->open_tags_stack->size > 0) {
     token_T* expected_tag = hb_array_last(parser->open_tags_stack);
     token_T* actual_tag = close_tag->tag_name;
 
@@ -217,5 +217,5 @@ bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_t
 
   if (hb_string_is_empty(tag_name) || hb_string_is_empty(expected_tag_name)) { return false; }
 
-  return hb_string_equals(expected_tag_name, tag_name);
+  return hb_string_equals_case_insensitive(expected_tag_name, tag_name);
 }

data/src/pretty_print.c

@@ -113,7 +113,7 @@ void pretty_print_array(
     return;
   }
 
-  if (hb_array_size(array) == 0) {
+  if (array->size == 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", 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++) {
       AST_NODE_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, "├── ");
@@ -142,7 +142,7 @@ void pretty_print_array(
 
       ast_pretty_print_node(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); }
     }
   }
   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 && hb_array_size(node->errors) > 0) {
+  if (node->errors != NULL && node->errors->size > 0) {
     error_pretty_print_array("errors", node->errors, indent, relative_indent, last_property, buffer);
     hb_buffer_append(buffer, "\n");
   }