herb 0.7.5 → 0.8.0

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

@@ -0,0 +1,374 @@
+use crate::errors::{AnyError, ErrorNode};
+use crate::{Location, Token};
+use colored::*;
+
+fn escape_string(s: &str) -> String {
+  s.replace('\\', "\\\\")
+    .replace('\n', "\\n")
+    .replace('\r', "\\r")
+    .replace('\t', "\\t")
+    .replace('"', "\\\"")
+}
+
+fn format_string_value(value: &str) -> String {
+  format!("\"{}\"", escape_string(value)).green().to_string()
+}
+
+fn format_token_value(token: &Option<Token>) -> String {
+  token.as_ref().map(|t| t.tree_inspect()).unwrap_or_else(|| "∅".magenta().to_string())
+}
+
+fn format_bool_value(value: bool) -> String {
+  value.to_string().magenta().bold().to_string()
+}
+
+fn format_node_value<T: Node + ?Sized>(node: &Option<Box<T>>, prefix: &str, add_spacing: bool) -> String {
+  if let Some(ref n) = node {
+    let mut output = String::new();
+    output.push('\n');
+    output.push_str(&inspect_node_field(n.as_ref(), prefix));
+    if add_spacing {
+      output.push_str(&format!("{}\n", prefix));
+    }
+    output
+  } else {
+    format!("{}\n", "∅".magenta())
+  }
+}
+
+fn format_array_value(array: &[AnyNode], prefix: &str) -> String {
+  inspect_array(array, prefix)
+}
+
+fn format_errors_field(errors: &[AnyError], prefix: &str) -> String {
+  inspect_errors(errors, prefix)
+}
+
+fn inspect_errors(errors: &[AnyError], prefix: &str) -> String {
+  if errors.is_empty() {
+    return String::new();
+  }
+
+  let mut output = String::new();
+  output.push_str(&format!("{} {}: {}\n",
+    "├──".white(),
+    "errors".red().bold(),
+    format!("({} error{})", errors.len(), if errors.len() == 1 { "" } else { "s" }).dimmed()
+  ));
+
+  for (i, error) in errors.iter().enumerate() {
+    let is_last = i == errors.len() - 1;
+    let symbol = if is_last { "└── " } else { "├── " };
+    let next_prefix_str = if is_last { "    " } else { "│   " };
+    let next_prefix = next_prefix_str.white().to_string();
+
+    let tree = error.tree_inspect();
+    let tree = tree.trim_end_matches('\n');
+    output.push_str(&format!("{}{}{}\n", prefix, symbol.white(), tree.replace('\n', &format!("\n{}{}", prefix, next_prefix))));
+
+    if !is_last {
+      output.push_str(&format!("{}{}\n", prefix, "│   ".white()));
+    }
+  }
+
+  output.push_str(&format!("{}\n", prefix));
+  output
+}
+
+fn inspect_array(array: &[AnyNode], prefix: &str) -> String {
+  if array.is_empty() {
+    return format!("{}\n", "[]".dimmed());
+  }
+
+  let mut output = String::new();
+  output.push_str(&format!("{}\n", format!("({} item{})", array.len(), if array.len() == 1 { "" } else { "s" }).dimmed()));
+
+  for (i, item) in array.iter().enumerate() {
+    let is_last = i == array.len() - 1;
+    let symbol = if is_last { "└── " } else { "├── " };
+    let next_prefix_str = if is_last { "    " } else { "│   " };
+    let next_prefix = next_prefix_str.white().to_string();
+
+    let tree = item.tree_inspect();
+    let tree = tree.trim_end_matches('\n');
+
+    output.push_str(prefix);
+    output.push_str(&symbol.white().to_string());
+    output.push_str(&tree.replace('\n', &format!("\n{}{}", prefix, next_prefix)));
+    output.push('\n');
+
+    if !is_last {
+      output.push_str(prefix);
+      output.push_str(&next_prefix);
+      output.push('\n');
+    }
+  }
+
+  output
+}
+
+fn inspect_node_field<T: Node + ?Sized>(node: &T, prefix: &str) -> String {
+  let tree = node.tree_inspect();
+  let tree = tree.trim_end_matches('\n');
+
+  let lines: Vec<&str> = tree.split('\n').collect();
+  if lines.is_empty() {
+    return format!("{}\n", "∅".magenta());
+  }
+
+  let mut result = String::new();
+  result.push_str(prefix);
+  result.push_str(&"└── ".white().to_string());
+  result.push_str(lines[0]);
+  result.push('\n');
+
+  for line in lines.iter().skip(1) {
+    if line.is_empty() {
+      result.push_str(prefix);
+      result.push('\n');
+    } else {
+      result.push_str(prefix);
+      result.push_str("    ");
+      result.push_str(line);
+      result.push('\n');
+    }
+  }
+
+  result
+}
+
+pub trait Node {
+  fn node_type(&self) -> &str;
+  fn location(&self) -> &Location;
+  fn errors(&self) -> &[AnyError];
+  fn child_nodes(&self) -> Vec<&dyn Node>;
+  fn recursive_errors(&self) -> Vec<&dyn ErrorNode>;
+  fn tree_inspect(&self) -> String;
+}
+
+#[derive(Debug, Clone)]
+pub enum AnyNode {
+  <%- nodes.each do |node| -%>
+  <%= node.name %>(<%= node.name %>),
+  <%- end -%>
+}
+
+impl AnyNode {
+  pub fn node_type(&self) -> &str {
+    match self {
+      <%- nodes.each do |node| -%>
+      AnyNode::<%= node.name %>(n) => &n.node_type,
+      <%- end -%>
+    }
+  }
+
+  pub fn location(&self) -> &Location {
+    match self {
+      <%- nodes.each do |node| -%>
+      AnyNode::<%= node.name %>(n) => &n.location,
+      <%- end -%>
+    }
+  }
+
+  pub fn errors(&self) -> &[AnyError] {
+    match self {
+      <%- nodes.each do |node| -%>
+      AnyNode::<%= node.name %>(n) => &n.errors,
+      <%- end -%>
+    }
+  }
+
+  pub fn tree_inspect(&self) -> String {
+    match self {
+      <%- nodes.each do |node| -%>
+      AnyNode::<%= node.name %>(n) => n.tree_inspect(),
+      <%- end -%>
+    }
+  }
+
+  pub fn child_nodes(&self) -> Vec<&dyn Node> {
+    match self {
+      <%- nodes.each do |node| -%>
+      AnyNode::<%= node.name %>(n) => n.child_nodes(),
+      <%- end -%>
+    }
+  }
+
+  pub fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+    match self {
+      <%- nodes.each do |node| -%>
+      AnyNode::<%= node.name %>(n) => n.recursive_errors(),
+      <%- end -%>
+    }
+  }
+}
+
+impl Node for AnyNode {
+  fn node_type(&self) -> &str {
+    self.node_type()
+  }
+
+  fn location(&self) -> &Location {
+    self.location()
+  }
+
+  fn errors(&self) -> &[AnyError] {
+    self.errors()
+  }
+
+  fn child_nodes(&self) -> Vec<&dyn Node> {
+    self.child_nodes()
+  }
+
+  fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+    self.recursive_errors()
+  }
+
+  fn tree_inspect(&self) -> String {
+    self.tree_inspect()
+  }
+}
+
+<%- nodes.each do |node| -%>
+#[derive(Debug, Clone)]
+pub struct <%= node.name %> {
+  pub node_type: String,
+  pub location: Location,
+  pub errors: Vec<AnyError>,
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  pub <%= field.name %>: String,
+  <%- when Herb::Template::TokenField -%>
+  pub <%= field.name %>: Option<Token>,
+  <%- when Herb::Template::BooleanField -%>
+  pub <%= field.name %>: bool,
+  <%- when Herb::Template::ArrayField -%>
+  pub <%= field.name %>: Vec<AnyNode>,
+  <%- when Herb::Template::NodeField -%>
+  <%- if field.specific_kind && field.specific_kind != "Node" -%>
+  pub <%= field.name %>: Option<Box<<%= field.specific_kind %>>>,
+  <%- else -%>
+  pub <%= field.name %>: Option<Box<AnyNode>>,
+  <%- end -%>
+  <%- when Herb::Template::ElementSourceField -%>
+  pub <%= field.name %>: String,
+  <%- end -%>
+  <%- end -%>
+}
+
+impl Node for <%= node.name %> {
+  fn node_type(&self) -> &str {
+    &self.node_type
+  }
+
+  fn location(&self) -> &Location {
+    &self.location
+  }
+
+  fn errors(&self) -> &[AnyError] {
+    &self.errors
+  }
+
+  fn child_nodes(&self) -> Vec<&dyn Node> {
+    <%- has_children = node.fields.any? { |field|
+      case field
+      when Herb::Template::ArrayField
+        true
+      when Herb::Template::NodeField
+        true
+      else
+        false
+      end
+    } -%>
+    <%- if has_children -%>
+    let mut children: Vec<&dyn Node> = Vec::new();
+    <%- node.fields.each do |field| -%>
+    <%- case field -%>
+    <%- when Herb::Template::ArrayField -%>
+    children.extend(self.<%= field.name %>.iter().map(|n| n as &dyn Node));
+    <%- when Herb::Template::NodeField -%>
+    if let Some(ref node) = self.<%= field.name %> {
+      <%- if field.specific_kind && field.specific_kind != "Node" -%>
+      children.push(node.as_ref() as &dyn Node);
+      <%- else -%>
+      children.push(node.as_ref() as &dyn Node);
+      <%- end -%>
+    }
+    <%- end -%>
+    <%- end -%>
+    children
+    <%- else -%>
+    Vec::new()
+    <%- end -%>
+  }
+
+  fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+    <%- has_children = node.fields.any? { |field|
+      case field
+      when Herb::Template::ArrayField
+        true
+      when Herb::Template::NodeField
+        true
+      else
+        false
+      end
+    } -%>
+    <%- if has_children -%>
+    let mut all_errors: Vec<&dyn ErrorNode> = Vec::new();
+    all_errors.extend(self.errors.iter().map(|e| e as &dyn ErrorNode));
+
+    <%- node.fields.each do |field| -%>
+    <%- case field -%>
+    <%- when Herb::Template::ArrayField -%>
+    for child in &self.<%= field.name %> {
+      all_errors.extend(child.recursive_errors());
+    }
+    <%- when Herb::Template::NodeField -%>
+    if let Some(ref node) = self.<%= field.name %> {
+      all_errors.extend(node.recursive_errors());
+    }
+    <%- end -%>
+    <%- end -%>
+
+    all_errors
+    <%- else -%>
+    self.errors.iter().map(|e| e as &dyn ErrorNode).collect()
+    <%- end -%>
+  }
+
+  fn tree_inspect(&self) -> String {
+    let mut output = String::new();
+
+    output.push_str(&format!("{} {} {}\n",
+      "@".white(),
+      "<%= node.name %>".yellow().bold(),
+      format!("(location: {})", self.location).dimmed()
+    ));
+    output.push_str(&format_errors_field(&self.errors, &<%- if node.fields.any? -%>"│   "<%- else -%>"  "<%- end -%>.white().to_string()));
+    <%- if node.fields.any? -%>
+    <%- node.fields.each_with_index do |field, index| -%>
+    <%- is_last = index == node.fields.length - 1 -%>
+    <%- symbol = is_last ? "└── " : "├── " -%>
+    <%- case field -%>
+    <%- when Herb::Template::StringField, Herb::Template::ElementSourceField -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_string_value(&self.<%= field.name %>)));
+    <%- when Herb::Template::TokenField -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_token_value(&self.<%= field.name %>)));
+    <%- when Herb::Template::BooleanField -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_bool_value(self.<%= field.name %>)));
+    <%- when Herb::Template::ArrayField -%>
+    output.push_str(&format!("{}{}: {}", "<%= symbol %>".white(), "<%= field.name %>".white(), format_array_value(&self.<%= field.name %>, &"<%= is_last ? "    " : "│   " %>".white().to_string())));
+    <%- when Herb::Template::NodeField -%>
+    output.push_str(&format!("{}{}: {}", "<%= symbol %>".white(), "<%= field.name %>".white(), format_node_value(&self.<%= field.name %>, &"<%= is_last ? "    " : "│   " %>".white().to_string(), <%= !is_last %>)));
+    <%- end -%>
+    <%- end -%>
+    <%- else -%>
+    output.push_str(&format!("{} {}\n", "└──".white(), "(no fields)".dimmed()));
+    <%- end -%>
+
+    output
+  }
+}
+
+<%- end -%>

data/templates/src/analyze_missing_end.c.erb

@@ -0,0 +1,36 @@
+#include "include/analyze_helpers.h"
+#include "include/errors.h"
+
+<%-
+  nodes_with_end_node = nodes.select do |node|
+    node.fields.any? { |field| field.name == "end_node" && field.is_a?(Herb::Template::NodeField) }
+  end
+-%>
+
+void check_erb_node_for_missing_end(const AST_NODE_T* node) {
+  switch (node->type) {
+    <%- nodes_with_end_node.each do |node| -%>
+    <%- keyword = node.name.gsub(/^ERB/, '').gsub(/Match|Node$/, '').downcase -%>
+    case <%= node.type %>: {
+      const <%= node.struct_type %>* <%= node.human %> = (const <%= node.struct_type %>*) node;
+
+      if (<%= node.human %>->end_node == NULL) {
+        append_missingerb_end_tag_error(
+        <%- if keyword == "block" -%>
+          "ERB block",
+        <%- else -%>
+          "`<" "%" " <%= keyword %> " "%" ">`",
+        <%- end -%>
+          <%= node.human %>->tag_opening->location.start,
+          <%= node.human %>->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    <%- end -%>
+    default: break;
+  }
+}

data/templates/src/analyze_transform.c.erb

@@ -0,0 +1,24 @@
+#include "include/analyze.h"
+#include "include/visitor.h"
+
+bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
+  analyze_ruby_context_T* context = (analyze_ruby_context_T*) data;
+  context->parent = (AST_NODE_T*) node;
+
+  <%- nodes.each do |node| -%>
+  <%- node.fields.each do |field| -%>
+  <%- if field.is_a?(Herb::Template::ArrayField) && field.name != "errors" -%>
+  if (node->type == <%= node.type %>) {
+    <%= node.struct_type %>* <%= node.human %> = (<%= node.struct_type %>*) node;
+    hb_array_T* old_array = <%= node.human %>-><%= field.name %>;
+    <%= node.human %>-><%= field.name %> = rewrite_node_array((AST_NODE_T*) node, <%= node.human %>-><%= field.name %>, context);
+    hb_array_free(&old_array);
+  }
+
+  <%- end -%>
+  <%- end -%>
+  <%- end -%>
+  herb_visit_child_nodes(node, transform_erb_nodes, data);
+
+  return false;
+}

data/templates/src/ast_nodes.c.erb

@@ -4,16 +4,16 @@
 #include <prism.h>
 
 #include "include/analyzed_ruby.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
 #include "include/token.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors"] -%>
 
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>) {
   <%= node.struct_type %>* <%= node.human %> = malloc(sizeof(<%= node.struct_type %>));
@@ -49,36 +49,36 @@
 }
 <%- end -%>
 
-const char* ast_node_type_to_string(AST_NODE_T* node) {
+hb_string_T ast_node_type_to_string(AST_NODE_T* node) {
   switch (node->type) {
     <%- nodes.each do |node| -%>
-    case <%= node.type %>: return "<%= node.type %>";
+    case <%= node.type %>: return hb_string("<%= node.type %>");
     <%- end -%>
   }
 
-  return "Unknown ast_node_type_T";
+  return hb_string("Unknown ast_node_type_T");
 }
 
-const char* ast_node_human_type(AST_NODE_T* node) {
+hb_string_T ast_node_human_type(AST_NODE_T* node) {
   switch (node->type) {
     <%- nodes.each do |node| -%>
-    case <%= node.type %>: return "<%= node.name %>";
+    case <%= node.type %>: return hb_string("<%= node.name %>");
     <%- end -%>
   }
 
-  return "Unknown ast_node_type_T";
+  return hb_string("Unknown ast_node_type_T");
 }
 
 void ast_free_base_node(AST_NODE_T* node) {
   if (node == NULL) { return; }
 
   if (node->errors) {
-    for (size_t i = 0; i < array_size(node->errors); i++) {
-      ERROR_T* child = array_get(node->errors, i);
+    for (size_t i = 0; i < hb_array_size(node->errors); i++) {
+      ERROR_T* child = hb_array_get(node->errors, i);
       if (child != NULL) { error_free(child); }
     }
 
-    array_free(&node->errors);
+    hb_array_free(&node->errors);
   }
 
   free(node);
@@ -99,12 +99,12 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
   ast_node_free((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::ArrayField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) {
-    for (size_t i = 0; i < array_size(<%= node.human %>-><%= field.name %>); i++) {
-      AST_NODE_T* child = array_get(<%= node.human %>-><%= field.name %>, i);
+    for (size_t i = 0; i < hb_array_size(<%= node.human %>-><%= field.name %>); i++) {
+      AST_NODE_T* child = hb_array_get(<%= node.human %>-><%= field.name %>, i);
       if (child) { ast_node_free(child); }
     }
 
-    array_free(&<%= node.human %>-><%= field.name %>);
+    hb_array_free(&<%= node.human %>-><%= field.name %>);
   }
   <%- when Herb::Template::StringField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) { free((char*) <%= node.human %>-><%= field.name %>); }

data/templates/src/ast_pretty_print.c.erb

@@ -1,27 +1,27 @@
 #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) {
     <%- nodes.each do |node| -%>
@@ -33,58 +33,58 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       <%- last = index == node.fields.length - 1 -%>
       <%- case field -%>
       <%- when Herb::Template::TokenField -%>
-      pretty_print_token_property(<%= node.human %>-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      pretty_print_token_property(<%= node.human %>-><%= field.name %>, hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::ArrayField -%>
-      pretty_print_array("<%= field.name %>", <%= node.human %>-><%= field.name %>, indent, relative_indent, <%= last %>, buffer);
+      pretty_print_array(hb_string("<%= field.name %>"), <%= node.human %>-><%= field.name %>, indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::BooleanField -%>
-      pretty_print_boolean_property("<%= field.name %>", <%= node.human %>-><%= field.name %>, indent, relative_indent, <%= last %>, buffer);
+      pretty_print_boolean_property(hb_string("<%= field.name %>"), <%= node.human %>-><%= field.name %>, indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::ElementSourceField -%>
-      pretty_print_string_property(element_source_to_string(<%= node.human %>-><%= field.name %>), "<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      pretty_print_string_property(element_source_to_string(<%= node.human %>-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::StringField -%>
-      pretty_print_string_property(<%= node.human %>-><%= field.name %>, "<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      pretty_print_string_property(hb_string(<%= node.human %>-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::PrismNodeField -%>
-      pretty_print_string_property("<%= field.name %>", "<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      pretty_print_string_property(hb_string("<%= field.name %>"), hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::NodeField -%>
 
-      pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
+      pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
 
       if (<%= node.human %>-><%= field.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*) <%= node.human %>-><%= field.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");
 
       <%- when Herb::Template::AnalyzedRubyField -%>
       if (<%= node.human %>-><%= field.name %>) {
-        pretty_print_boolean_property("if_node", <%= node.human %>-><%= field.name %>->has_if_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("elsif_node", <%= node.human %>-><%= field.name %>->has_elsif_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("else_node", <%= node.human %>-><%= field.name %>->has_else_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("end", <%= node.human %>-><%= field.name %>->has_end, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("block_node", <%= node.human %>-><%= field.name %>->has_block_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("block_closing", <%= node.human %>-><%= field.name %>->has_block_closing, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("case_node", <%= node.human %>-><%= field.name %>->has_case_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("when_node", <%= node.human %>-><%= field.name %>->has_when_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("for_node", <%= node.human %>-><%= field.name %>->has_for_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("while_node", <%= node.human %>-><%= field.name %>->has_while_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("until_node", <%= node.human %>-><%= field.name %>->has_until_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("begin_node", <%= node.human %>-><%= field.name %>->has_begin_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("rescue_node", <%= node.human %>-><%= field.name %>->has_rescue_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property("ensure_node", <%= node.human %>-><%= field.name %>->has_ensure_node, indent, relative_indent,  <%= last %>, buffer);
-        pretty_print_boolean_property("unless_node", <%= node.human %>-><%= field.name %>->has_unless_node, indent, relative_indent,  <%= last %>, buffer);
+        pretty_print_boolean_property(hb_string("if_node"), <%= node.human %>-><%= field.name %>->has_if_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("elsif_node"), <%= node.human %>-><%= field.name %>->has_elsif_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("else_node"), <%= node.human %>-><%= field.name %>->has_else_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("end"), <%= node.human %>-><%= field.name %>->has_end, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_node"), <%= node.human %>-><%= field.name %>->has_block_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_closing"), <%= node.human %>-><%= field.name %>->has_block_closing, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("case_node"), <%= node.human %>-><%= field.name %>->has_case_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("when_node"), <%= node.human %>-><%= field.name %>->has_when_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("for_node"), <%= node.human %>-><%= field.name %>->has_for_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("while_node"), <%= node.human %>-><%= field.name %>->has_while_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("until_node"), <%= node.human %>-><%= field.name %>->has_until_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("begin_node"), <%= node.human %>-><%= field.name %>->has_begin_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("rescue_node"), <%= node.human %>-><%= field.name %>->has_rescue_node, indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("ensure_node"), <%= node.human %>-><%= field.name %>->has_ensure_node, indent, relative_indent,  <%= last %>, buffer);
+        pretty_print_boolean_property(hb_string("unless_node"), <%= node.human %>-><%= field.name %>->has_unless_node, indent, relative_indent,  <%= last %>, buffer);
       } else {
-      pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
-        buffer_append(buffer, " ∅\n");
+      pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
+        hb_buffer_append(buffer, " ∅\n");
       }
 
       <%- when Herb::Template::VoidPointerField -%>
-      pretty_print_label("<%= field.name %>", indent, relative_indent, <%= last %>, buffer);
-      buffer_append(buffer, " ?\n");
+      pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
+      hb_buffer_append(buffer, " ?\n");
 
       <%- else -%>
       <%= field.inspect %>