herb 0.7.5 → 0.8.0

data/src/errors.c

@@ -1,13 +1,13 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
 // be modified manually. See /home/runner/work/herb/herb/templates/src/errors.c.erb
 
-#include "include/array.h"
 #include "include/errors.h"
 #include "include/location.h"
 #include "include/position.h"
 #include "include/pretty_print.h"
 #include "include/token.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -72,8 +72,8 @@ UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* e
   return unexpected_error;
 }
 
-void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, array_T* errors) {
-  array_append(errors, unexpected_error_init(description, expected, found, start, end));
+void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, unexpected_error_init(description, expected, found, start, end));
 }
 
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end) {
@@ -81,9 +81,9 @@ UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type
 
   error_init(&unexpected_token_error->base, UNEXPECTED_TOKEN_ERROR, start, end);
 
-  const char* message_template = "Found `%s` when expecting `%s` at (%zu:%zu).";
+  const char* message_template = "Found `%s` when expecting `%s` at (%u:%u).";
 
-  size_t message_size = 333;
+  size_t message_size = 319;
   char* message = (char*) malloc(message_size);
 
   if (message) {
@@ -108,7 +108,7 @@ UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type
     unexpected_token_error->base.message = herb_strdup(message);
     free(message);
   } else {
-    unexpected_token_error->base.message = herb_strdup("Found `%s` when expecting `%s` at (%zu:%zu).");
+    unexpected_token_error->base.message = herb_strdup("Found `%s` when expecting `%s` at (%u:%u).");
   }
 
   unexpected_token_error->expected_type = expected_type;
@@ -116,8 +116,8 @@ UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type
   return unexpected_token_error;
 }
 
-void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, array_T* errors) {
-  array_append(errors, unexpected_token_error_init(expected_type, found, start, end));
+void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, unexpected_token_error_init(expected_type, found, start, end));
 }
 
 MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag, position_T start, position_T end) {
@@ -125,9 +125,9 @@ MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag
 
   error_init(&missing_opening_tag_error->base, MISSING_OPENING_TAG_ERROR, start, end);
 
-  const char* message_template = "Found closing tag `</%s>` at (%zu:%zu) without a matching opening tag.";
+  const char* message_template = "Found closing tag `</%s>` at (%u:%u) without a matching opening tag in the same scope.";
 
-  size_t message_size = 231;
+  size_t message_size = 235;
   char* message = (char*) malloc(message_size);
 
   if (message) {
@@ -147,15 +147,15 @@ MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag
     missing_opening_tag_error->base.message = herb_strdup(message);
     free(message);
   } else {
-    missing_opening_tag_error->base.message = herb_strdup("Found closing tag `</%s>` at (%zu:%zu) without a matching opening tag.");
+    missing_opening_tag_error->base.message = herb_strdup("Found closing tag `</%s>` at (%u:%u) without a matching opening tag in the same scope.");
   }
 
   missing_opening_tag_error->closing_tag = token_copy(closing_tag);
   return missing_opening_tag_error;
 }
 
-void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, array_T* errors) {
-  array_append(errors, missing_opening_tag_error_init(closing_tag, start, end));
+void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, missing_opening_tag_error_init(closing_tag, start, end));
 }
 
 MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag, position_T start, position_T end) {
@@ -163,9 +163,9 @@ MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag
 
   error_init(&missing_closing_tag_error->base, MISSING_CLOSING_TAG_ERROR, start, end);
 
-  const char* message_template = "Opening tag `<%s>` at (%zu:%zu) doesn't have a matching closing tag `</%s>`.";
+  const char* message_template = "Opening tag `<%s>` at (%u:%u) doesn't have a matching closing tag `</%s>` in the same scope.";
 
-  size_t message_size = 365;
+  size_t message_size = 369;
   char* message = (char*) malloc(message_size);
 
   if (message) {
@@ -190,15 +190,15 @@ MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag
     missing_closing_tag_error->base.message = herb_strdup(message);
     free(message);
   } else {
-    missing_closing_tag_error->base.message = herb_strdup("Opening tag `<%s>` at (%zu:%zu) doesn't have a matching closing tag `</%s>`.");
+    missing_closing_tag_error->base.message = herb_strdup("Opening tag `<%s>` at (%u:%u) doesn't have a matching closing tag `</%s>` in the same scope.");
   }
 
   missing_closing_tag_error->opening_tag = token_copy(opening_tag);
   return missing_closing_tag_error;
 }
 
-void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, array_T* errors) {
-  array_append(errors, missing_closing_tag_error_init(opening_tag, start, end));
+void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, missing_closing_tag_error_init(opening_tag, start, end));
 }
 
 TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end) {
@@ -206,9 +206,9 @@ TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag,
 
   error_init(&tag_names_mismatch_error->base, TAG_NAMES_MISMATCH_ERROR, start, end);
 
-  const char* message_template = "Opening tag `<%s>` at (%zu:%zu) closed with `</%s>` at (%zu:%zu).";
+  const char* message_template = "Opening tag `<%s>` at (%u:%u) closed with `</%s>` at (%u:%u).";
 
-  size_t message_size = 386;
+  size_t message_size = 358;
   char* message = (char*) malloc(message_size);
 
   if (message) {
@@ -235,7 +235,7 @@ TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag,
     tag_names_mismatch_error->base.message = herb_strdup(message);
     free(message);
   } else {
-    tag_names_mismatch_error->base.message = herb_strdup("Opening tag `<%s>` at (%zu:%zu) closed with `</%s>` at (%zu:%zu).");
+    tag_names_mismatch_error->base.message = herb_strdup("Opening tag `<%s>` at (%u:%u) closed with `</%s>` at (%u:%u).");
   }
 
   tag_names_mismatch_error->opening_tag = token_copy(opening_tag);
@@ -243,8 +243,8 @@ TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag,
   return tag_names_mismatch_error;
 }
 
-void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, array_T* errors) {
-  array_append(errors, tag_names_mismatch_error_init(opening_tag, closing_tag, start, end));
+void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, tag_names_mismatch_error_init(opening_tag, closing_tag, start, end));
 }
 
 QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end) {
@@ -252,9 +252,9 @@ QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, toke
 
   error_init(&quotes_mismatch_error->base, QUOTES_MISMATCH_ERROR, start, end);
 
-  const char* message_template = "String opened with %s but closed with %s at (%zu:%zu).";
+  const char* message_template = "String opened with %s but closed with %s at (%u:%u).";
 
-  size_t message_size = 343;
+  size_t message_size = 329;
   char* message = (char*) malloc(message_size);
 
   if (message) {
@@ -279,7 +279,7 @@ QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, toke
     quotes_mismatch_error->base.message = herb_strdup(message);
     free(message);
   } else {
-    quotes_mismatch_error->base.message = herb_strdup("String opened with %s but closed with %s at (%zu:%zu).");
+    quotes_mismatch_error->base.message = herb_strdup("String opened with %s but closed with %s at (%u:%u).");
   }
 
   quotes_mismatch_error->opening_quote = token_copy(opening_quote);
@@ -287,8 +287,8 @@ QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, toke
   return quotes_mismatch_error;
 }
 
-void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end, array_T* errors) {
-  array_append(errors, quotes_mismatch_error_init(opening_quote, closing_quote, start, end));
+void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, quotes_mismatch_error_init(opening_quote, closing_quote, start, end));
 }
 
 VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end) {
@@ -340,8 +340,8 @@ VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* t
   return void_element_closing_tag_error;
 }
 
-void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end, array_T* errors) {
-  array_append(errors, void_element_closing_tag_error_init(tag_name, expected, found, start, end));
+void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, void_element_closing_tag_error_init(tag_name, expected, found, start, end));
 }
 
 UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, position_T start, position_T end) {
@@ -349,9 +349,9 @@ UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, posi
 
   error_init(&unclosed_element_error->base, UNCLOSED_ELEMENT_ERROR, start, end);
 
-  const char* message_template = "Tag `<%s>` opened at (%zu:%zu) was never closed before the end of document.";
+  const char* message_template = "Tag `<%s>` opened at (%u:%u) was never closed before the end of document.";
 
-  size_t message_size = 236;
+  size_t message_size = 222;
   char* message = (char*) malloc(message_size);
 
   if (message) {
@@ -371,15 +371,15 @@ UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, posi
     unclosed_element_error->base.message = herb_strdup(message);
     free(message);
   } else {
-    unclosed_element_error->base.message = herb_strdup("Tag `<%s>` opened at (%zu:%zu) was never closed before the end of document.");
+    unclosed_element_error->base.message = herb_strdup("Tag `<%s>` opened at (%u:%u) was never closed before the end of document.");
   }
 
   unclosed_element_error->opening_tag = token_copy(opening_tag);
   return unclosed_element_error;
 }
 
-void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, array_T* errors) {
-  array_append(errors, unclosed_element_error_init(opening_tag, start, end));
+void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, unclosed_element_error_init(opening_tag, start, end));
 }
 
 RUBY_PARSE_ERROR_T* ruby_parse_error_init(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end) {
@@ -421,8 +421,80 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_init(const char* error_message, const char*
   return ruby_parse_error;
 }
 
-void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end, array_T* errors) {
-  array_append(errors, ruby_parse_error_init(error_message, diagnostic_id, level, start, end));
+void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, ruby_parse_error_init(error_message, diagnostic_id, level, start, end));
+}
+
+ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* keyword, position_T start, position_T end) {
+  ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error = malloc(sizeof(ERB_CONTROL_FLOW_SCOPE_ERROR_T));
+
+  error_init(&erb_control_flow_scope_error->base, ERB_CONTROL_FLOW_SCOPE_ERROR, start, end);
+
+  const char* message_template = "%s appears outside its control flow block. Keep ERB control flow statements together within the same HTML scope (tag, attribute, or content).";
+
+  size_t message_size = 270;
+  char* message = (char*) malloc(message_size);
+
+  if (message) {
+    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
+    strncpy(truncated_argument_0, keyword, ERROR_MESSAGES_TRUNCATED_LENGTH);
+    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
+
+    snprintf(
+      message,
+      message_size,
+      message_template,
+      truncated_argument_0
+    );
+
+    erb_control_flow_scope_error->base.message = herb_strdup(message);
+    free(message);
+  } else {
+    erb_control_flow_scope_error->base.message = herb_strdup("%s appears outside its control flow block. Keep ERB control flow statements together within the same HTML scope (tag, attribute, or content).");
+  }
+
+  erb_control_flow_scope_error->keyword = herb_strdup(keyword);
+  return erb_control_flow_scope_error;
+}
+
+void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, erb_control_flow_scope_error_init(keyword, start, end));
+}
+
+MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end) {
+  MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error = malloc(sizeof(MISSINGERB_END_TAG_ERROR_T));
+
+  error_init(&missingerb_end_tag_error->base, MISSINGERB_END_TAG_ERROR, start, end);
+
+  const char* message_template = "%s started here but never closed with an end tag. The end tag may be in a different scope.";
+
+  size_t message_size = 219;
+  char* message = (char*) malloc(message_size);
+
+  if (message) {
+    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
+    strncpy(truncated_argument_0, keyword, ERROR_MESSAGES_TRUNCATED_LENGTH);
+    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
+
+    snprintf(
+      message,
+      message_size,
+      message_template,
+      truncated_argument_0
+    );
+
+    missingerb_end_tag_error->base.message = herb_strdup(message);
+    free(message);
+  } else {
+    missingerb_end_tag_error->base.message = herb_strdup("%s started here but never closed with an end tag. The end tag may be in a different scope.");
+  }
+
+  missingerb_end_tag_error->keyword = herb_strdup(keyword);
+  return missingerb_end_tag_error;
+}
+
+void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, missingerb_end_tag_error_init(keyword, start, end));
 }
 
 const char* error_type_to_string(ERROR_T* error) {
@@ -436,6 +508,8 @@ const char* error_type_to_string(ERROR_T* error) {
     case VOID_ELEMENT_CLOSING_TAG_ERROR: return "VOID_ELEMENT_CLOSING_TAG_ERROR";
     case UNCLOSED_ELEMENT_ERROR: return "UNCLOSED_ELEMENT_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";
   }
 
   return "Unknown error_type_T";
@@ -452,6 +526,8 @@ const char* error_human_type(ERROR_T* error) {
     case VOID_ELEMENT_CLOSING_TAG_ERROR: return "VoidElementClosingTagError";
     case UNCLOSED_ELEMENT_ERROR: return "UnclosedElementError";
     case RUBY_PARSE_ERROR: return "RubyParseError";
+    case ERB_CONTROL_FLOW_SCOPE_ERROR: return "ERBControlFlowScopeError";
+    case MISSINGERB_END_TAG_ERROR: return "MissingERBEndTagError";
   }
 
   return "Unknown error_type_T";
@@ -528,6 +604,18 @@ static void error_free_ruby_parse_error(RUBY_PARSE_ERROR_T* ruby_parse_error) {
   error_free_base_error(&ruby_parse_error->base);
 }
 
+static void error_free_erb_control_flow_scope_error(ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error) {
+  if (erb_control_flow_scope_error->keyword != NULL) { free((char*) erb_control_flow_scope_error->keyword); }
+
+  error_free_base_error(&erb_control_flow_scope_error->base);
+}
+
+static void error_free_missingerb_end_tag_error(MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error) {
+  if (missingerb_end_tag_error->keyword != NULL) { free((char*) missingerb_end_tag_error->keyword); }
+
+  error_free_base_error(&missingerb_end_tag_error->base);
+}
+
 void error_free(ERROR_T* error) {
   if (!error) { return; }
 
@@ -541,189 +629,219 @@ void error_free(ERROR_T* error) {
     case VOID_ELEMENT_CLOSING_TAG_ERROR: error_free_void_element_closing_tag_error((VOID_ELEMENT_CLOSING_TAG_ERROR_T*) error); break;
     case UNCLOSED_ELEMENT_ERROR: error_free_unclosed_element_error((UNCLOSED_ELEMENT_ERROR_T*) error); break;
     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;
   }
 }
 
 void error_pretty_print_array(
-  const char* name, array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
-  buffer_T* buffer
+  const char* name, hb_array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
+  hb_buffer_T* buffer
 ) {
   if (array == NULL) {
-    pretty_print_property(name, "∅", indent, relative_indent, last_property, buffer);
+    pretty_print_property(hb_string(name), hb_string("∅"), indent, relative_indent, last_property, buffer);
 
     return;
   }
 
-  if (array_size(array) == 0) {
-    pretty_print_property(name, "[]", indent, relative_indent, last_property, buffer);
+  if (hb_array_size(array) == 0) {
+    pretty_print_property(hb_string(name), hb_string("[]"), indent, relative_indent, last_property, buffer);
 
     return;
   }
 
-  pretty_print_label(name, indent, relative_indent, last_property, buffer);
+  pretty_print_label(hb_string(name), indent, relative_indent, last_property, buffer);
 
-  buffer_append(buffer, "(");
+  hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array_size(array));
-  buffer_append(buffer, count);
-  buffer_append(buffer, ")\n");
+  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(array); i++) {
-      ERROR_T* child = array_get(array, 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(array) - 1) {
-        buffer_append(buffer, "└── ");
+      if (i == hb_array_size(array) - 1) {
+        hb_buffer_append(buffer, "└── ");
       } else {
-        buffer_append(buffer, "├── ");
+        hb_buffer_append(buffer, "├── ");
       }
 
       error_pretty_print(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
 }
 
-static void error_pretty_print_unexpected_error(UNEXPECTED_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_unexpected_error(UNEXPECTED_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, false, buffer);
+  pretty_print_quoted_property(hb_string("description"), hb_string(error->description), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("expected"), hb_string(error->expected), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("found"), hb_string(error->found), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unexpected_token_error(UNEXPECTED_TOKEN_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, false, buffer);
+  pretty_print_property(hb_string(token_type_to_string(error->expected_type)), hb_string("expected_type"), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->found, hb_string("found"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_missing_opening_tag_error(MISSING_OPENING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_quoted_property("description", error->description, indent, relative_indent, false, buffer);
-  pretty_print_quoted_property("expected", error->expected, indent, relative_indent, false, buffer);
-  pretty_print_quoted_property("found", error->found, indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->closing_tag, hb_string("closing_tag"), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_unexpected_token_error(UNEXPECTED_TOKEN_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_missing_closing_tag_error(MISSING_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_property(token_type_to_string(error->expected_type), "expected_type", indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->found, "found", indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_missing_opening_tag_error(MISSING_OPENING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_tag_names_mismatch_error(TAG_NAMES_MISMATCH_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->closing_tag, "closing_tag", indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->closing_tag, hb_string("closing_tag"), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_missing_closing_tag_error(MISSING_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_quotes_mismatch_error(QUOTES_MISMATCH_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->opening_tag, "opening_tag", indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_quote, hb_string("opening_quote"), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->closing_quote, hb_string("closing_quote"), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_tag_names_mismatch_error(TAG_NAMES_MISMATCH_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_void_element_closing_tag_error(VOID_ELEMENT_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->opening_tag, "opening_tag", indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->closing_tag, "closing_tag", indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->tag_name, hb_string("tag_name"), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("expected"), hb_string(error->expected), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("found"), hb_string(error->found), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_quotes_mismatch_error(QUOTES_MISMATCH_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_unclosed_element_error(UNCLOSED_ELEMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->opening_quote, "opening_quote", indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->closing_quote, "closing_quote", indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_void_element_closing_tag_error(VOID_ELEMENT_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_ruby_parse_error(RUBY_PARSE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->tag_name, "tag_name", indent, relative_indent, false, buffer);
-  pretty_print_quoted_property("expected", error->expected, indent, relative_indent, false, buffer);
-  pretty_print_quoted_property("found", error->found, indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("error_message"), hb_string(error->error_message), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("diagnostic_id"), hb_string(error->diagnostic_id), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("level"), hb_string(error->level), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_unclosed_element_error(UNCLOSED_ELEMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_erb_control_flow_scope_error(ERB_CONTROL_FLOW_SCOPE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->opening_tag, "opening_tag", indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("keyword"), hb_string(error->keyword), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_ruby_parse_error(RUBY_PARSE_ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+static void error_pretty_print_missingerb_end_tag_error(MISSINGERB_END_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, error_human_type((ERROR_T*) error));
-  buffer_append(buffer, " ");
+  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);
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property("message", error->base.message, indent, relative_indent, false, buffer);
-  pretty_print_quoted_property("error_message", error->error_message, indent, relative_indent, false, buffer);
-  pretty_print_quoted_property("diagnostic_id", error->diagnostic_id, indent, relative_indent, false, buffer);
-  pretty_print_quoted_property("level", error->level, indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("keyword"), hb_string(error->keyword), indent, relative_indent, true, buffer);
 }
 
-void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   switch (error->type) {
@@ -736,5 +854,7 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     case VOID_ELEMENT_CLOSING_TAG_ERROR: error_pretty_print_void_element_closing_tag_error((VOID_ELEMENT_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case UNCLOSED_ELEMENT_ERROR: error_pretty_print_unclosed_element_error((UNCLOSED_ELEMENT_ERROR_T*) error, indent, relative_indent, buffer); break;
     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;
   }
 }