herb 0.7.5 → 0.8.0

data/src/ast_pretty_print.c

@@ -3,63 +3,63 @@
 
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/pretty_print.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
 
-void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t relative_indent, buffer_T* buffer) {
+void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!node) { return; }
 
   bool print_location = true;
 
-  buffer_append(buffer, "@ ");
-  buffer_append(buffer, ast_node_human_type(node));
-  buffer_append(buffer, " ");
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, ast_node_human_type(node));
+  hb_buffer_append(buffer, " ");
 
   if (print_location) { pretty_print_location(node->location, buffer); }
 
-  buffer_append(buffer, "\n");
+  hb_buffer_append(buffer, "\n");
 
   switch (node->type) {
     case AST_DOCUMENT_NODE: {
       const AST_DOCUMENT_NODE_T* document_node = (AST_DOCUMENT_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_array("children", document_node->children, indent, relative_indent, true, buffer);
+      pretty_print_array(hb_string("children"), document_node->children, indent, relative_indent, true, buffer);
     } break;
 
     case AST_LITERAL_NODE: {
       const AST_LITERAL_NODE_T* literal_node = (AST_LITERAL_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_string_property(literal_node->content, "content", indent, relative_indent, true, buffer);
+      pretty_print_string_property(hb_string(literal_node->content), hb_string("content"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_HTML_OPEN_TAG_NODE: {
       const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = (AST_HTML_OPEN_TAG_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_open_tag_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_open_tag_node->tag_name, "tag_name", indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_open_tag_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("children", html_open_tag_node->children, indent, relative_indent, false, buffer);
-      pretty_print_boolean_property("is_void", html_open_tag_node->is_void, indent, relative_indent, true, buffer);
+      pretty_print_token_property(html_open_tag_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_open_tag_node->tag_name, hb_string("tag_name"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_open_tag_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), html_open_tag_node->children, indent, relative_indent, false, buffer);
+      pretty_print_boolean_property(hb_string("is_void"), html_open_tag_node->is_void, indent, relative_indent, true, buffer);
     } break;
 
     case AST_HTML_CLOSE_TAG_NODE: {
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_close_tag_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_close_tag_node->tag_name, "tag_name", indent, relative_indent, false, buffer);
-      pretty_print_array("children", html_close_tag_node->children, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_close_tag_node->tag_closing, "tag_closing", indent, relative_indent, true, buffer);
+      pretty_print_token_property(html_close_tag_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_close_tag_node->tag_name, hb_string("tag_name"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), html_close_tag_node->children, indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_close_tag_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_HTML_ELEMENT_NODE: {
@@ -67,56 +67,56 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
 
-      pretty_print_label("open_tag", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("open_tag"), indent, relative_indent, false, buffer);
 
       if (html_element_node->open_tag) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) html_element_node->open_tag, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
-      pretty_print_token_property(html_element_node->tag_name, "tag_name", indent, relative_indent, false, buffer);
-      pretty_print_array("body", html_element_node->body, indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_element_node->tag_name, hb_string("tag_name"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("body"), html_element_node->body, indent, relative_indent, false, buffer);
 
-      pretty_print_label("close_tag", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("close_tag"), indent, relative_indent, false, buffer);
 
       if (html_element_node->close_tag) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) html_element_node->close_tag, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
-      pretty_print_boolean_property("is_void", html_element_node->is_void, indent, relative_indent, false, buffer);
-      pretty_print_string_property(element_source_to_string(html_element_node->source), "source", indent, relative_indent, true, buffer);
+      pretty_print_boolean_property(hb_string("is_void"), html_element_node->is_void, indent, relative_indent, false, buffer);
+      pretty_print_string_property(element_source_to_string(html_element_node->source), hb_string("source"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_HTML_ATTRIBUTE_VALUE_NODE: {
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = (AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_attribute_value_node->open_quote, "open_quote", indent, relative_indent, false, buffer);
-      pretty_print_array("children", html_attribute_value_node->children, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_attribute_value_node->close_quote, "close_quote", indent, relative_indent, false, buffer);
-      pretty_print_boolean_property("quoted", html_attribute_value_node->quoted, indent, relative_indent, true, buffer);
+      pretty_print_token_property(html_attribute_value_node->open_quote, hb_string("open_quote"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), html_attribute_value_node->children, indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_attribute_value_node->close_quote, hb_string("close_quote"), indent, relative_indent, false, buffer);
+      pretty_print_boolean_property(hb_string("quoted"), html_attribute_value_node->quoted, indent, relative_indent, true, buffer);
     } break;
 
     case AST_HTML_ATTRIBUTE_NAME_NODE: {
       const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = (AST_HTML_ATTRIBUTE_NAME_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_array("children", html_attribute_name_node->children, indent, relative_indent, true, buffer);
+      pretty_print_array(hb_string("children"), html_attribute_name_node->children, indent, relative_indent, true, buffer);
     } break;
 
     case AST_HTML_ATTRIBUTE_NODE: {
@@ -124,35 +124,35 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
 
-      pretty_print_label("name", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("name"), indent, relative_indent, false, buffer);
 
       if (html_attribute_node->name) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) html_attribute_node->name, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
-      pretty_print_token_property(html_attribute_node->equals, "equals", indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_attribute_node->equals, hb_string("equals"), indent, relative_indent, false, buffer);
 
-      pretty_print_label("value", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("value"), indent, relative_indent, true, buffer);
 
       if (html_attribute_node->value) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) html_attribute_node->value, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -160,140 +160,140 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_HTML_TEXT_NODE_T* html_text_node = (AST_HTML_TEXT_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_string_property(html_text_node->content, "content", indent, relative_indent, true, buffer);
+      pretty_print_string_property(hb_string(html_text_node->content), hb_string("content"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_HTML_COMMENT_NODE: {
       const AST_HTML_COMMENT_NODE_T* html_comment_node = (AST_HTML_COMMENT_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_comment_node->comment_start, "comment_start", indent, relative_indent, false, buffer);
-      pretty_print_array("children", html_comment_node->children, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_comment_node->comment_end, "comment_end", indent, relative_indent, true, buffer);
+      pretty_print_token_property(html_comment_node->comment_start, hb_string("comment_start"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), html_comment_node->children, indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_comment_node->comment_end, hb_string("comment_end"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_HTML_DOCTYPE_NODE: {
       const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = (AST_HTML_DOCTYPE_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_doctype_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_array("children", html_doctype_node->children, indent, relative_indent, false, buffer);
-      pretty_print_token_property(html_doctype_node->tag_closing, "tag_closing", indent, relative_indent, true, buffer);
+      pretty_print_token_property(html_doctype_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), html_doctype_node->children, indent, relative_indent, false, buffer);
+      pretty_print_token_property(html_doctype_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_XML_DECLARATION_NODE: {
       const AST_XML_DECLARATION_NODE_T* xml_declaration_node = (AST_XML_DECLARATION_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(xml_declaration_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_array("children", xml_declaration_node->children, indent, relative_indent, false, buffer);
-      pretty_print_token_property(xml_declaration_node->tag_closing, "tag_closing", indent, relative_indent, true, buffer);
+      pretty_print_token_property(xml_declaration_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), xml_declaration_node->children, indent, relative_indent, false, buffer);
+      pretty_print_token_property(xml_declaration_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_CDATA_NODE: {
       const AST_CDATA_NODE_T* cdata_node = (AST_CDATA_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(cdata_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_array("children", cdata_node->children, indent, relative_indent, false, buffer);
-      pretty_print_token_property(cdata_node->tag_closing, "tag_closing", indent, relative_indent, true, buffer);
+      pretty_print_token_property(cdata_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), cdata_node->children, indent, relative_indent, false, buffer);
+      pretty_print_token_property(cdata_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_WHITESPACE_NODE: {
       const AST_WHITESPACE_NODE_T* whitespace_node = (AST_WHITESPACE_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(whitespace_node->value, "value", indent, relative_indent, true, buffer);
+      pretty_print_token_property(whitespace_node->value, hb_string("value"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_ERB_CONTENT_NODE: {
       const AST_ERB_CONTENT_NODE_T* erb_content_node = (AST_ERB_CONTENT_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_content_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_content_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_content_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_content_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_content_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_content_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
       if (erb_content_node->analyzed_ruby) {
-        pretty_print_boolean_property("if_node", erb_content_node->analyzed_ruby->has_if_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("elsif_node", erb_content_node->analyzed_ruby->has_elsif_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("else_node", erb_content_node->analyzed_ruby->has_else_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("end", erb_content_node->analyzed_ruby->has_end, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("block_node", erb_content_node->analyzed_ruby->has_block_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("block_closing", erb_content_node->analyzed_ruby->has_block_closing, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("case_node", erb_content_node->analyzed_ruby->has_case_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("when_node", erb_content_node->analyzed_ruby->has_when_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("for_node", erb_content_node->analyzed_ruby->has_for_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("while_node", erb_content_node->analyzed_ruby->has_while_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("until_node", erb_content_node->analyzed_ruby->has_until_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("begin_node", erb_content_node->analyzed_ruby->has_begin_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("rescue_node", erb_content_node->analyzed_ruby->has_rescue_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("ensure_node", erb_content_node->analyzed_ruby->has_ensure_node, indent, relative_indent,  false, buffer);
-        pretty_print_boolean_property("unless_node", erb_content_node->analyzed_ruby->has_unless_node, indent, relative_indent,  false, buffer);
+        pretty_print_boolean_property(hb_string("if_node"), erb_content_node->analyzed_ruby->has_if_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("elsif_node"), erb_content_node->analyzed_ruby->has_elsif_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("else_node"), erb_content_node->analyzed_ruby->has_else_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("end"), erb_content_node->analyzed_ruby->has_end, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_node"), erb_content_node->analyzed_ruby->has_block_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_closing"), erb_content_node->analyzed_ruby->has_block_closing, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("case_node"), erb_content_node->analyzed_ruby->has_case_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("when_node"), erb_content_node->analyzed_ruby->has_when_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("for_node"), erb_content_node->analyzed_ruby->has_for_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("while_node"), erb_content_node->analyzed_ruby->has_while_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("until_node"), erb_content_node->analyzed_ruby->has_until_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("begin_node"), erb_content_node->analyzed_ruby->has_begin_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("rescue_node"), erb_content_node->analyzed_ruby->has_rescue_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("ensure_node"), erb_content_node->analyzed_ruby->has_ensure_node, indent, relative_indent,  false, buffer);
+        pretty_print_boolean_property(hb_string("unless_node"), erb_content_node->analyzed_ruby->has_unless_node, indent, relative_indent,  false, buffer);
       } else {
-      pretty_print_label("analyzed_ruby", indent, relative_indent, false, buffer);
-        buffer_append(buffer, " ∅\n");
+      pretty_print_label(hb_string("analyzed_ruby"), indent, relative_indent, false, buffer);
+        hb_buffer_append(buffer, " ∅\n");
       }
 
-      pretty_print_boolean_property("parsed", erb_content_node->parsed, indent, relative_indent, false, buffer);
-      pretty_print_boolean_property("valid", erb_content_node->valid, indent, relative_indent, true, buffer);
+      pretty_print_boolean_property(hb_string("parsed"), erb_content_node->parsed, indent, relative_indent, false, buffer);
+      pretty_print_boolean_property(hb_string("valid"), erb_content_node->valid, indent, relative_indent, true, buffer);
     } break;
 
     case AST_ERB_END_NODE: {
       const AST_ERB_END_NODE_T* erb_end_node = (AST_ERB_END_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_end_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_end_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_end_node->tag_closing, "tag_closing", indent, relative_indent, true, buffer);
+      pretty_print_token_property(erb_end_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_end_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_end_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_ERB_ELSE_NODE: {
       const AST_ERB_ELSE_NODE_T* erb_else_node = (AST_ERB_ELSE_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_else_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_else_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_else_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_else_node->statements, indent, relative_indent, true, buffer);
+      pretty_print_token_property(erb_else_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_else_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_else_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("statements"), erb_else_node->statements, indent, relative_indent, true, buffer);
     } break;
 
     case AST_ERB_IF_NODE: {
       const AST_ERB_IF_NODE_T* erb_if_node = (AST_ERB_IF_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_if_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_if_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_if_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_if_node->statements, indent, relative_indent, false, buffer);
+      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_array(hb_string("statements"), erb_if_node->statements, indent, relative_indent, false, buffer);
 
-      pretty_print_label("subsequent", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("subsequent"), indent, relative_indent, false, buffer);
 
       if (erb_if_node->subsequent) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_if_node->subsequent, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_if_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_if_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -301,24 +301,24 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_BLOCK_NODE_T* erb_block_node = (AST_ERB_BLOCK_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_block_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_block_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_block_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("body", erb_block_node->body, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_block_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_block_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_block_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("body"), erb_block_node->body, indent, relative_indent, false, buffer);
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_block_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_block_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -326,50 +326,50 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_WHEN_NODE_T* erb_when_node = (AST_ERB_WHEN_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_when_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_when_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_when_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_when_node->statements, indent, relative_indent, true, buffer);
+      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_array(hb_string("statements"), erb_when_node->statements, indent, relative_indent, true, buffer);
     } break;
 
     case AST_ERB_CASE_NODE: {
       const AST_ERB_CASE_NODE_T* erb_case_node = (AST_ERB_CASE_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_case_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_case_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_case_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("children", erb_case_node->children, indent, relative_indent, false, buffer);
-      pretty_print_array("conditions", erb_case_node->conditions, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), erb_case_node->children, indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("conditions"), erb_case_node->conditions, indent, relative_indent, false, buffer);
 
-      pretty_print_label("else_clause", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("else_clause"), indent, relative_indent, false, buffer);
 
       if (erb_case_node->else_clause) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_case_node->else_clause, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_case_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_case_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -377,40 +377,40 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (AST_ERB_CASE_MATCH_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_case_match_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_case_match_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_case_match_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("children", erb_case_match_node->children, indent, relative_indent, false, buffer);
-      pretty_print_array("conditions", erb_case_match_node->conditions, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("children"), erb_case_match_node->children, indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("conditions"), erb_case_match_node->conditions, indent, relative_indent, false, buffer);
 
-      pretty_print_label("else_clause", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("else_clause"), indent, relative_indent, false, buffer);
 
       if (erb_case_match_node->else_clause) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_case_match_node->else_clause, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_case_match_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_case_match_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -418,24 +418,24 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_WHILE_NODE_T* erb_while_node = (AST_ERB_WHILE_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_while_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_while_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_while_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_while_node->statements, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_while_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_while_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_while_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("statements"), erb_while_node->statements, indent, relative_indent, false, buffer);
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_while_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_while_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -443,24 +443,24 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_UNTIL_NODE_T* erb_until_node = (AST_ERB_UNTIL_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_until_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_until_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_until_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_until_node->statements, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_until_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_until_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_until_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("statements"), erb_until_node->statements, indent, relative_indent, false, buffer);
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_until_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_until_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -468,24 +468,24 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_FOR_NODE_T* erb_for_node = (AST_ERB_FOR_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_for_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_for_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_for_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_for_node->statements, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_for_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_for_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_for_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("statements"), erb_for_node->statements, indent, relative_indent, false, buffer);
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_for_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_for_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -493,24 +493,24 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_RESCUE_NODE_T* erb_rescue_node = (AST_ERB_RESCUE_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_rescue_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_rescue_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_rescue_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_rescue_node->statements, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_rescue_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_rescue_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_rescue_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("statements"), erb_rescue_node->statements, indent, relative_indent, false, buffer);
 
-      pretty_print_label("subsequent", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("subsequent"), indent, relative_indent, true, buffer);
 
       if (erb_rescue_node->subsequent) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_rescue_node->subsequent, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -518,79 +518,79 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_ENSURE_NODE_T* erb_ensure_node = (AST_ERB_ENSURE_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_ensure_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_ensure_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_ensure_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_ensure_node->statements, indent, relative_indent, true, buffer);
+      pretty_print_token_property(erb_ensure_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_ensure_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_ensure_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("statements"), erb_ensure_node->statements, indent, relative_indent, true, buffer);
     } break;
 
     case AST_ERB_BEGIN_NODE: {
       const AST_ERB_BEGIN_NODE_T* erb_begin_node = (AST_ERB_BEGIN_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_begin_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_begin_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_begin_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_begin_node->statements, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_begin_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_begin_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_begin_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_array(hb_string("statements"), erb_begin_node->statements, indent, relative_indent, false, buffer);
 
-      pretty_print_label("rescue_clause", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("rescue_clause"), indent, relative_indent, false, buffer);
 
       if (erb_begin_node->rescue_clause) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_begin_node->rescue_clause, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
 
-      pretty_print_label("else_clause", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("else_clause"), indent, relative_indent, false, buffer);
 
       if (erb_begin_node->else_clause) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_begin_node->else_clause, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
 
-      pretty_print_label("ensure_clause", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("ensure_clause"), indent, relative_indent, false, buffer);
 
       if (erb_begin_node->ensure_clause) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_begin_node->ensure_clause, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_begin_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_begin_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -598,39 +598,39 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_UNLESS_NODE_T* erb_unless_node = (AST_ERB_UNLESS_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_unless_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_unless_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_unless_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_unless_node->statements, indent, relative_indent, false, buffer);
+      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_array(hb_string("statements"), erb_unless_node->statements, indent, relative_indent, false, buffer);
 
-      pretty_print_label("else_clause", indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("else_clause"), indent, relative_indent, false, buffer);
 
       if (erb_unless_node->else_clause) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_unless_node->else_clause, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
 
-      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+      pretty_print_label(hb_string("end_node"), indent, relative_indent, true, buffer);
 
       if (erb_unless_node->end_node) {
-        buffer_append(buffer, "\n");
+        hb_buffer_append(buffer, "\n");
         pretty_print_indent(buffer, indent);
         pretty_print_indent(buffer, relative_indent + 1);
 
-        buffer_append(buffer, "└── ");
+        hb_buffer_append(buffer, "└── ");
         ast_pretty_print_node((AST_NODE_T*) erb_unless_node->end_node, indent, relative_indent + 2, buffer);
       } else {
-        buffer_append(buffer, " ∅\n");
+        hb_buffer_append(buffer, " ∅\n");
       }
-      buffer_append(buffer, "\n");
+      hb_buffer_append(buffer, "\n");
 
     } break;
 
@@ -638,19 +638,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       const AST_ERB_YIELD_NODE_T* erb_yield_node = (AST_ERB_YIELD_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_yield_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_yield_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_yield_node->tag_closing, "tag_closing", indent, relative_indent, true, buffer);
+      pretty_print_token_property(erb_yield_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_yield_node->content, hb_string("content"), indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_yield_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, true, buffer);
     } break;
 
     case AST_ERB_IN_NODE: {
       const AST_ERB_IN_NODE_T* erb_in_node = (AST_ERB_IN_NODE_T*) node;
 
       pretty_print_errors(node, indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_in_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_in_node->content, "content", indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_in_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
-      pretty_print_array("statements", erb_in_node->statements, indent, relative_indent, true, buffer);
+      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_array(hb_string("statements"), erb_in_node->statements, indent, relative_indent, true, buffer);
     } break;
 
   }