herb 0.8.10-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/templates/lib/herb/errors.rb.erb

@@ -1,5 +1,10 @@
-<%- base_arguments = [["type", "String"], ["location", "Location"], ["message", "String"]] -%>
+<%- base_arguments = [["type", "String"], ["location", "Location?"], ["message", "String"]] -%>
 module Herb
+  #: type serialized_error = {
+  #|  type: String,
+  #|  location: serialized_location?,
+  #|  message: String
+  #| }
   module Errors
     class Error
       <%- base_arguments.each do |argument, type| -%>
@@ -49,7 +54,12 @@ module Herb
       <%- if error.fields.any? -%>
 
       <%- error.fields.each do |field| -%>
-      attr_reader :<%= field.name %> #: <%= field.ruby_type %>
+      #|  <%= "#{field.name}: #{field.ruby_type}?," %>
+      <%- end -%>
+      #| }
+
+      <%- error.fields.each do |field| -%>
+      attr_reader :<%= field.name %> #: <%= field.ruby_type %>?
       <%- end -%>
 
       #: (<%= [*base_arguments.map(&:last), *error.fields.map(&:ruby_type)].join(", ") %>) -> void
@@ -81,7 +91,7 @@ module Herb
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
         <%- symbol = error.fields.none? ? "└──" : "├──" -%>
         output += white("<%= symbol %> message: #{green(message.inspect)}\n")
         <%- error.fields.each do |field| -%>
@@ -99,6 +109,8 @@ module Herb
         output += white("<%= symbol %> <%= field.name %>: #{green(<%= field.name %>.inspect)}\n")
         <%- when Herb::Template::StringField -%>
         output += white("<%= symbol %> <%= field.name %>: #{green(<%= field.name %>.inspect)}\n")
+        <%- when Herb::Template::SizeTField -%>
+        output += white("<%= symbol %> <%= field.name %>: #{green(<%= field.name %>.inspect)}\n")
         <%- else -%>
         output += white("<%= symbol %> <%= field.name %>: ") + '#{<%= field.name %>.class}'\n"
         <%- end -%>

data/templates/lib/herb/visitor.rb.erb

@@ -2,12 +2,12 @@ module Herb
   class Visitor
     include AST::Helpers
 
-    #: (Herb::AST::Node) -> void
+    #: (Herb::AST::Node?) -> void
     def visit(node)
       node&.accept(self)
     end
 
-    #: (Array[Herb::AST::Node]) -> void
+    #: (Array[Herb::AST::Node?]) -> void
     def visit_all(nodes)
       nodes.each { |node| node&.accept(self) }
     end

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

@@ -1,10 +1,10 @@
 use crate::bindings::*;
-use crate::convert::token_from_c;
+use crate::convert::{token_from_c, string_from_hb_string};
 use crate::errors::*;
 use crate::nodes::*;
+use crate::union_types::*;
 use crate::{Location, Position};
-use std::ffi::CStr;
-use std::os::raw::{c_char, c_void};
+use std::os::raw::c_void;
 
 unsafe fn convert_location(c_location: location_T) -> Location {
   Location::new(
@@ -13,15 +13,15 @@ unsafe fn convert_location(c_location: location_T) -> Location {
   )
 }
 
+unsafe fn convert_position(c_position: position_T) -> Position {
+  Position::new(c_position.line, c_position.column)
+}
+
 <%- errors.each do |error| -%>
-<%- snake_name = error.name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase -%>
+<%- snake_name = Herb::Template.underscore(error.name).downcase -%>
 unsafe fn convert_<%= snake_name %>(error_ptr: *const <%= error.c_type %>) -> <%= error.name %> {
   let error_ref = &*error_ptr;
-  let message = if error_ref.base.message.is_null() {
-    String::new()
-  } else {
-    CStr::from_ptr(error_ref.base.message).to_string_lossy().into_owned()
-  };
+  let message = string_from_hb_string(error_ref.base.message);
   let location = convert_location(error_ref.base.location);
 
   <%= error.name %>::new(
@@ -37,8 +37,12 @@ unsafe fn convert_<%= snake_name %>(error_ptr: *const <%= error.c_type %>) -> <%
     if error_ref.<%= field.name %> == u32::MAX {
       None
     } else {
-      Some(CStr::from_ptr(crate::ffi::token_type_to_string(error_ref.<%= field.name %>)).to_string_lossy().into_owned())
+      Some(string_from_hb_string(crate::ffi::token_type_to_string(error_ref.<%= field.name %>)))
     },
+    <%- when Herb::Template::SizeTField -%>
+    error_ref.<%= field.name %>,
+    <%- when Herb::Template::PositionField -%>
+    Some(convert_position(error_ref.<%= field.name %>)),
     <%- end -%>
     <%- end -%>
   )
@@ -64,7 +68,7 @@ unsafe fn convert_errors(errors_array: *mut hb_array_T) -> Vec<AnyError> {
 
     let error = match error_base.type_ {
         <%- errors.each do |error| -%>
-        <%- snake_name = error.name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase -%>
+        <%- snake_name = Herb::Template.underscore(error.name).downcase -%>
         <%= error.type %> => {
           let error_ptr = error_base_ptr as *const <%= error.c_type %>;
           AnyError::<%= error.name %>(convert_<%= snake_name %>(error_ptr))
@@ -79,16 +83,11 @@ unsafe fn convert_errors(errors_array: *mut hb_array_T) -> Vec<AnyError> {
   errors
 }
 
-unsafe fn get_string_field(string_ptr: *const c_char) -> String {
-  if string_ptr.is_null() {
-    String::new()
-  } else {
-    CStr::from_ptr(string_ptr).to_string_lossy().into_owned()
-  }
+unsafe fn get_string_field(hb_string: hb_string_T) -> String {
+  string_from_hb_string(hb_string)
 }
 
-unsafe fn convert_element_source(source: u32) -> String {
-  let hb_string = crate::ffi::element_source_to_string(source);
+unsafe fn convert_element_source(hb_string: hb_string_T) -> String {
   if hb_string.data.is_null() {
     String::new()
   } else {
@@ -133,20 +132,21 @@ unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec<AnyNode> {
   children
 }
 
-unsafe fn convert_node_field(node_ptr: *mut c_void) -> Option<Box<AnyNode>> {
-  if node_ptr.is_null() {
+#[allow(dead_code)]
+unsafe fn convert_node_field(node_pointer: *mut c_void) -> Option<Box<AnyNode>> {
+  if node_pointer.is_null() {
     None
   } else {
-    convert_node(node_ptr).map(Box::new)
+    convert_node(node_pointer).map(Box::new)
   }
 }
 
 macro_rules! convert_specific_node_field {
-  ($node_ptr:expr, $expected_type:expr, $convert_fn:ident, $node_type:ty) => {
-    if $node_ptr.is_null() {
+  ($node_pointer:expr, $expected_type:expr, $convert_fn:ident, $node_type:ty) => {
+    if $node_pointer.is_null() {
       None
     } else {
-      let ast_base_ptr = $node_ptr as *const AST_NODE_T;
+      let ast_base_ptr = $node_pointer as *const AST_NODE_T;
       let ast_base_ref = &*ast_base_ptr;
       let node_type = ast_base_ref.type_;
 
@@ -154,24 +154,24 @@ macro_rules! convert_specific_node_field {
         eprintln!("Warning: Expected node type {} but got {}", $expected_type, node_type);
         None
       } else {
-        $convert_fn($node_ptr as *const c_void).map(Box::new)
+        $convert_fn($node_pointer as *const c_void).map(Box::new)
       }
     }
   };
 }
 
-unsafe fn convert_node(node_ptr: *const c_void) -> Option<AnyNode> {
-  if node_ptr.is_null() {
+unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode> {
+  if node_pointer.is_null() {
     return None;
   }
 
-  let ast_base_ptr = node_ptr as *const AST_NODE_T;
+  let ast_base_ptr = node_pointer as *const AST_NODE_T;
   let ast_base_ref = &*ast_base_ptr;
   let node_type = ast_base_ref.type_;
 
   match node_type {
     <%- nodes.each do |node| -%>
-    <%= node.type %> => convert_<%= node.human %>(node_ptr).map(AnyNode::<%= node.name %>),
+    <%= node.type %> => convert_<%= node.human %>(node_pointer).map(|n| AnyNode::<%= node.name %>(Box::new(n))),
     <%- end -%>
     _ => {
       eprintln!("Warning: Unknown node type {}", node_type);
@@ -186,16 +186,16 @@ unsafe fn convert_node(node_ptr: *const c_void) -> Option<AnyNode> {
   ///
   /// # Safety
   ///
-  /// The caller must ensure that `node_ptr` is a valid pointer to a C document node
+  /// The caller must ensure that `node_pointer` is a valid pointer to a C document node
   /// structure with properly initialized fields.
   <%- end -%>
-  <%= node.name == "DocumentNode" ? "pub " : "" %>unsafe fn convert_<%= node.human %>(node_ptr: *const c_void) -> Option<<%= node.name %>> {
-    if node_ptr.is_null() {
+  <%= node.name == "DocumentNode" ? "pub " : "" %>unsafe fn convert_<%= node.human %>(node_pointer: *const c_void) -> Option<<%= node.name %>> {
+    if node_pointer.is_null() {
       return None;
     }
 
-    let c_node_ptr = node_ptr as *const <%= node.c_type %>;
-    let node_base_ref = &(*c_node_ptr).base;
+    let c_node_pointer = node_pointer as *const <%= node.c_type %>;
+    let node_base_ref = &(*c_node_pointer).base;
 
     Some(<%= node.name %> {
       node_type: "<%= node.name %>".to_string(),
@@ -204,27 +204,80 @@ unsafe fn convert_node(node_ptr: *const c_void) -> Option<AnyNode> {
       <%- node.fields.each do |field| -%>
       <%- case field -%>
       <%- when Herb::Template::StringField -%>
-      <%= field.name %>: get_string_field((*c_node_ptr).<%= field.name %>),
+      <%= field.name %>: get_string_field((*c_node_pointer).<%= field.name %>),
       <%- when Herb::Template::ElementSourceField -%>
-      <%= field.name %>: convert_element_source((*c_node_ptr).<%= field.name %>),
+      <%= field.name %>: convert_element_source((*c_node_pointer).<%= field.name %>),
       <%- when Herb::Template::TokenField -%>
-      <%= field.name %>: convert_token_field((*c_node_ptr).<%= field.name %>),
+      <%= field.name %>: convert_token_field((*c_node_pointer).<%= field.name %>),
       <%- when Herb::Template::BooleanField -%>
-      <%= field.name %>: (*c_node_ptr).<%= field.name %>,
+      <%= field.name %>: (*c_node_pointer).<%= field.name %>,
       <%- when Herb::Template::ArrayField -%>
-      <%= field.name %>: convert_children((*c_node_ptr).<%= field.name %>),
-      <%- when Herb::Template::NodeField -%>
+      <%= field.name %>: convert_children((*c_node_pointer).<%= field.name %>),
+      <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
       <%- if field.specific_kind && field.specific_kind != "Node" -%>
       <%- specific_node = nodes.find { |n| n.name == field.specific_kind } -%>
-      <%= field.name %>: convert_specific_node_field!((*c_node_ptr).<%= field.name %>, <%= specific_node.type %>, convert_<%= specific_node.human %>, <%= field.specific_kind %>),
+      <%= field.name %>: convert_specific_node_field!((*c_node_pointer).<%= field.name %>, <%= specific_node.type %>, convert_<%= specific_node.human %>, <%= field.specific_kind %>),
+      <%- elsif field.union_kind -%>
+      <%- snake_name = Herb::Template.underscore(field.union_type_name).downcase -%>
+      <%= field.name %>: convert_<%= snake_name %>_field((*c_node_pointer).<%= field.name %> as *mut c_void),
       <%- else -%>
-      <%= field.name %>: convert_node_field((*c_node_ptr).<%= field.name %> as *mut c_void),
+      <%= field.name %>: convert_node_field((*c_node_pointer).<%= field.name %> as *mut c_void),
       <%- end -%>
       <%- when Herb::Template::LocationField -%>
-      <%= field.name %>: convert_location_field((*c_node_ptr).<%= field.name %>),
+      <%= field.name %>: convert_location_field((*c_node_pointer).<%= field.name %>),
+      <%- when Herb::Template::PrismSerializedField -%>
+      <%= field.name %>: if (*c_node_pointer).<%= field.name %>.data.is_null() || (*c_node_pointer).<%= field.name %>.length == 0 {
+        None
+      } else {
+        Some(std::slice::from_raw_parts((*c_node_pointer).<%= field.name %>.data, (*c_node_pointer).<%= field.name %>.length).to_vec())
+      },
+      <%- when Herb::Template::PrismNodeField -%>
+      <%= field.name %>: if (*c_node_pointer).<%= field.name %>.node.is_null() || (*c_node_pointer).<%= field.name %>.parser.is_null() {
+        None
+      } else {
+        let mut pm_buffer: crate::bindings::pm_buffer_t = std::mem::zeroed();
+        crate::bindings::pm_prettyprint(&mut pm_buffer, (*c_node_pointer).<%= field.name %>.parser, (*c_node_pointer).<%= field.name %>.node);
+
+        if pm_buffer.length > 0 && !pm_buffer.value.is_null() {
+          let s = std::str::from_utf8(std::slice::from_raw_parts(pm_buffer.value as *const u8, pm_buffer.length)).unwrap_or("").to_string();
+          crate::bindings::pm_buffer_free(&mut pm_buffer);
+          Some(s)
+        } else {
+          crate::bindings::pm_buffer_free(&mut pm_buffer);
+          None
+        }
+      },
+      <%- when Herb::Template::AnalyzedRubyField, Herb::Template::PrismContextField -%>
+      // skip internal field: <%= field.name %>
       <%- end -%>
       <%- end -%>
     })
   }
 
 <%- end -%>
+<%- union_kinds.each do |kinds| -%>
+<%-
+  enum_name = kinds.sort.join("Or")
+  snake_name = Herb::Template.underscore(enum_name).downcase
+-%>
+#[allow(dead_code)]
+unsafe fn convert_<%= snake_name %>_field(node_pointer: *mut c_void) -> Option<<%= enum_name %>> {
+  if node_pointer.is_null() {
+    return None;
+  }
+
+  let base_node = node_pointer as *const AST_NODE_STRUCT;
+  let node_type = (*base_node).type_;
+
+  match node_type {
+    <%- kinds.each do |kind| -%>
+    <%- node = nodes.find { |n| n.name == kind } -%>
+    <%= node.type %> => {
+      Some(<%= enum_name %>::<%= kind %>(Box::new(convert_<%= node.human %>(node_pointer as *const c_void)?)))
+    }
+    <%- end -%>
+    _ => None,
+  }
+}
+
+<%- end -%>

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

@@ -1,4 +1,4 @@
-use crate::{Location, Token};
+use crate::{Location, Position, Token};
 use colored::*;
 
 fn escape_string(s: &str) -> String {
@@ -136,6 +136,7 @@ pub struct <%= error.name %> {
   <%- end -%>
 }
 
+#[allow(clippy::too_many_arguments)]
 impl <%= error.name %> {
   pub fn new(
     message: String,

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

@@ -1,7 +1,29 @@
 use crate::errors::{AnyError, ErrorNode};
 use crate::{Location, Token};
+use crate::union_types::*;
 use colored::*;
 
+pub(crate) fn prettify_prism_tree(input: &str) -> String {
+  let input = input.replace("+-- ", "├── ").replace("|   ", "│   ");
+  let lines: Vec<&str> = input.lines().collect();
+  let mut result: Vec<String> = lines.iter().map(|l| l.to_string()).collect();
+
+  for i in 0..result.len() {
+    if let Some(position) = result[i].find("├── ") {
+      let indent = &result[i][..position];
+      let is_last = !lines[i + 1..].iter().any(|next| {
+        next.starts_with(&format!("{}├── ", indent)) || next.starts_with(&format!("{}│   ", indent))
+      });
+
+      if is_last {
+        result[i] = format!("{}└── {}", indent, &result[i][position + "├── ".len()..]);
+      }
+    }
+  }
+
+  result.join("\n")
+}
+
 fn escape_string(s: &str) -> String {
   s.replace('\\', "\\\\")
     .replace('\n', "\\n")
@@ -36,6 +58,38 @@ fn format_node_value<T: Node + ?Sized>(node: &Option<Box<T>>, prefix: &str, add_
   }
 }
 
+fn format_union_node_value<T>(node: &Option<T>, prefix: &str, add_spacing: bool, tree_inspect_fn: impl Fn(&T) -> String) -> String {
+  if let Some(ref n) = node {
+    let mut output = String::new();
+    output.push('\n');
+    let tree = tree_inspect_fn(n);
+    let lines: Vec<&str> = tree.lines().collect();
+    if !lines.is_empty() {
+      output.push_str(prefix);
+      output.push_str(&"└── ".white().to_string());
+      output.push_str(lines[0]);
+      output.push('\n');
+      for line in lines.iter().skip(1) {
+        if line.is_empty() {
+          output.push_str(prefix);
+          output.push('\n');
+        } else {
+          output.push_str(prefix);
+          output.push_str("    ");
+          output.push_str(line);
+          output.push('\n');
+        }
+      }
+    }
+    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)
 }
@@ -146,10 +200,17 @@ pub trait Node {
   fn tree_inspect(&self) -> String;
 }
 
+pub trait ERBNode {
+  fn tag_opening(&self) -> &Option<Token>;
+  fn content(&self) -> &Option<Token>;
+  fn tag_closing(&self) -> &Option<Token>;
+  fn location(&self) -> &Location;
+}
+
 #[derive(Debug, Clone)]
 pub enum AnyNode {
   <%- nodes.each do |node| -%>
-  <%= node.name %>(<%= node.name %>),
+  <%= node.name %>(Box<<%= node.name %>>),
   <%- end -%>
 }
 
@@ -245,9 +306,11 @@ pub struct <%= node.name %> {
   pub <%= field.name %>: bool,
   <%- when Herb::Template::ArrayField -%>
   pub <%= field.name %>: Vec<AnyNode>,
-  <%- when Herb::Template::NodeField -%>
+  <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
   <%- if field.specific_kind && field.specific_kind != "Node" -%>
   pub <%= field.name %>: Option<Box<<%= field.specific_kind %>>>,
+  <%- elsif field.union_kind -%>
+  pub <%= field.name %>: Option<<%= field.union_type_name %>>,
   <%- else -%>
   pub <%= field.name %>: Option<Box<AnyNode>>,
   <%- end -%>
@@ -255,6 +318,12 @@ pub struct <%= node.name %> {
   pub <%= field.name %>: String,
   <%- when Herb::Template::LocationField -%>
   pub <%= field.name %>: Option<Location>,
+  <%- when Herb::Template::PrismSerializedField -%>
+  pub <%= field.name %>: Option<Vec<u8>>,
+  <%- when Herb::Template::PrismNodeField -%>
+  pub <%= field.name %>: Option<String>,
+  <%- when Herb::Template::AnalyzedRubyField, Herb::Template::PrismContextField -%>
+  // no-op for <%= field.name %>
   <%- end -%>
   <%- end -%>
 }
@@ -277,7 +346,7 @@ impl Node for <%= node.name %> {
       case field
       when Herb::Template::ArrayField
         true
-      when Herb::Template::NodeField
+      when Herb::Template::BorrowedNodeField, Herb::Template::NodeField
         true
       else
         false
@@ -289,10 +358,12 @@ impl Node for <%= node.name %> {
     <%- case field -%>
     <%- when Herb::Template::ArrayField -%>
     children.extend(self.<%= field.name %>.iter().map(|n| n as &dyn Node));
-    <%- when Herb::Template::NodeField -%>
+    <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
     if let Some(ref node) = self.<%= field.name %> {
       <%- if field.specific_kind && field.specific_kind != "Node" -%>
       children.push(node.as_ref() as &dyn Node);
+      <%- elsif field.union_kind -%>
+      children.push(node.as_node());
       <%- else -%>
       children.push(node.as_ref() as &dyn Node);
       <%- end -%>
@@ -310,7 +381,7 @@ impl Node for <%= node.name %> {
       case field
       when Herb::Template::ArrayField
         true
-      when Herb::Template::NodeField
+      when Herb::Template::BorrowedNodeField, Herb::Template::NodeField
         true
       else
         false
@@ -326,7 +397,7 @@ impl Node for <%= node.name %> {
     for child in &self.<%= field.name %> {
       all_errors.extend(child.recursive_errors());
     }
-    <%- when Herb::Template::NodeField -%>
+    <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
     if let Some(ref node) = self.<%= field.name %> {
       all_errors.extend(node.recursive_errors());
     }
@@ -349,22 +420,83 @@ impl Node for <%= node.name %> {
     ));
     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 ? "└── " : "├── " -%>
+    <%- node.field_visibilities.each do |visibility| -%>
+    <%- field = visibility.field -%>
+    <%- next if field.always_invisible? -%>
+    <%- if field.conditionally_invisible? -%>
+    <%- case field -%>
+    <%- when Herb::Template::PrismSerializedField -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= visibility.symbol %>".white(), "<%= field.name %>".white(), self.<%= field.name %>.as_ref().map(|b| format!("({} bytes)", b.len()).dimmed().to_string()).unwrap_or_else(|| "∅".magenta().to_string())));
+    <%- when Herb::Template::PrismNodeField -%>
+    if let Some(ref prism_string) = self.<%= field.name %> {
+      let prefix = "<%= visibility.prefix %>";
+      output.push_str(&format!("{}{}: \n", "<%= visibility.symbol %>".white(), "<%= field.name %>".white()));
+      output.push_str(&format!("{}└── ", prefix));
+      let prettified = prettify_prism_tree(prism_string);
+      let indented = prettified.lines().enumerate().map(|(i, line)| {
+        if i == 0 { line.to_string() } else { format!("{}    {}", prefix, line) }
+      }).collect::<Vec<_>>().join("\n");
+      output.push_str(&indented);
+      output.push('\n');
+    }
+    <%- end -%>
+    <%- else -%>
+    <%- if visibility.dynamic_last? -%>
+    { let is_last = self.<%= visibility.prism_field_name %>.is_none(); let symbol = if is_last { "└── " } else { "├── " };
+    <%- end -%>
     <%- 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 %>)));
+    <%- if visibility.dynamic_last? -%>
+    output.push_str(&format!("{}{}: {}\n", symbol.white(), "<%= field.name %>".white(), format_string_value(&self.<%= field.name %>)));
+    <%- else -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= visibility.symbol %>".white(), "<%= field.name %>".white(), format_string_value(&self.<%= field.name %>)));
+    <%- end -%>
     <%- when Herb::Template::TokenField -%>
-    output.push_str(&format!("{}{}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_token_value(&self.<%= field.name %>)));
+    <%- if visibility.dynamic_last? -%>
+    output.push_str(&format!("{}{}: {}\n", symbol.white(), "<%= field.name %>".white(), format_token_value(&self.<%= field.name %>)));
+    <%- else -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= visibility.symbol %>".white(), "<%= field.name %>".white(), format_token_value(&self.<%= field.name %>)));
+    <%- end -%>
     <%- when Herb::Template::BooleanField -%>
-    output.push_str(&format!("{}{}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_bool_value(self.<%= field.name %>)));
+    <%- if visibility.dynamic_last? -%>
+    output.push_str(&format!("{}{}: {}\n", symbol.white(), "<%= field.name %>".white(), format_bool_value(self.<%= field.name %>)));
+    <%- else -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= visibility.symbol %>".white(), "<%= field.name %>".white(), format_bool_value(self.<%= field.name %>)));
+    <%- end -%>
     <%- 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 %>)));
+    <%- if visibility.dynamic_last? -%>
+    let child_prefix = if is_last { "    " } else { "│   " };
+    output.push_str(&format!("{}{}: {}", symbol.white(), "<%= field.name %>".white(), format_array_value(&self.<%= field.name %>, &child_prefix.white().to_string())));
+    <%- else -%>
+    output.push_str(&format!("{}{}: {}", "<%= visibility.symbol %>".white(), "<%= field.name %>".white(), format_array_value(&self.<%= field.name %>, &"<%= visibility.prefix %>".white().to_string())));
+    <%- end -%>
+    <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
+    <%- if visibility.dynamic_last? -%>
+    let child_prefix = if is_last { "    " } else { "│   " };
+    <%- if field.union_kind -%>
+    output.push_str(&format!("{}{}: {}", symbol.white(), "<%= field.name %>".white(), format_union_node_value(&self.<%= field.name %>, &child_prefix.white().to_string(), !is_last, |n: &<%= field.union_type_name %>| n.tree_inspect())));
+    <%- else -%>
+    output.push_str(&format!("{}{}: {}", symbol.white(), "<%= field.name %>".white(), format_node_value(&self.<%= field.name %>, &child_prefix.white().to_string(), !is_last)));
+    <%- end -%>
+    <%- else -%>
+    <%- if field.union_kind -%>
+    output.push_str(&format!("{}{}: {}", "<%= visibility.symbol %>".white(), "<%= field.name %>".white(), format_union_node_value(&self.<%= field.name %>, &"<%= visibility.prefix %>".white().to_string(), <%= !visibility.static_last? %>, |n: &<%= field.union_type_name %>| n.tree_inspect())));
+    <%- else -%>
+    output.push_str(&format!("{}{}: {}", "<%= visibility.symbol %>".white(), "<%= field.name %>".white(), format_node_value(&self.<%= field.name %>, &"<%= visibility.prefix %>".white().to_string(), <%= !visibility.static_last? %>)));
+    <%- end -%>
+    <%- end -%>
     <%- when Herb::Template::LocationField -%>
-    output.push_str(&format!("{}{}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), self.<%= field.name %>.as_ref().map(|l| format!("(location: {})", l).dimmed().to_string()).unwrap_or_else(|| "∅".magenta().to_string())));
+    <%- if visibility.dynamic_last? -%>
+    output.push_str(&format!("{}{}: {}\n", symbol.white(), "<%= field.name %>".white(), self.<%= field.name %>.as_ref().map(|l| format!("(location: {})", l).dimmed().to_string()).unwrap_or_else(|| "∅".magenta().to_string())));
+    <%- else -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= visibility.symbol %>".white(), "<%= field.name %>".white(), self.<%= field.name %>.as_ref().map(|l| format!("(location: {})", l).dimmed().to_string()).unwrap_or_else(|| "∅".magenta().to_string())));
+    <%- end -%>
+    <%- else -%>
+    <% raise "Unhandled class #{field.class}" %>
+    <%- end -%>
+    <%- if visibility.dynamic_last? -%>
+    }
+    <%- end -%>
     <%- end -%>
     <%- end -%>
     <%- else -%>
@@ -375,4 +507,24 @@ impl Node for <%= node.name %> {
   }
 }
 
+<%- if node.name.start_with?("ERB") -%>
+impl ERBNode for <%= node.name %> {
+  fn tag_opening(&self) -> &Option<Token> {
+    &self.tag_opening
+  }
+
+  fn content(&self) -> &Option<Token> {
+    &self.content
+  }
+
+  fn tag_closing(&self) -> &Option<Token> {
+    &self.tag_closing
+  }
+
+  fn location(&self) -> &Location {
+    &self.location
+  }
+}
+
+<%- end -%>
 <%- end -%>

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

@@ -0,0 +1,60 @@
+use crate::nodes::*;
+use crate::errors::ErrorNode;
+use crate::Location;
+
+<%- union_kinds.each do |kinds| -%>
+<%-
+  enum_name = kinds.sort.join("Or")
+  snake_name = Herb::Template.underscore(enum_name).downcase
+-%>
+/// Union type for <%= kinds.join(" | ") %>
+#[derive(Debug, Clone)]
+pub enum <%= enum_name %> {
+  <%- kinds.each do |kind| -%>
+  <%= kind %>(Box<<%= kind %>>),
+  <%- end -%>
+}
+
+impl <%= enum_name %> {
+  pub fn node_type(&self) -> &str {
+    match self {
+      <%- kinds.each do |kind| -%>
+      <%= enum_name %>::<%= kind %>(n) => &n.node_type,
+      <%- end -%>
+    }
+  }
+
+  pub fn location(&self) -> &Location {
+    match self {
+      <%- kinds.each do |kind| -%>
+      <%= enum_name %>::<%= kind %>(n) => &n.location,
+      <%- end -%>
+    }
+  }
+
+  pub fn as_node(&self) -> &dyn Node {
+    match self {
+      <%- kinds.each do |kind| -%>
+      <%= enum_name %>::<%= kind %>(n) => n.as_ref(),
+      <%- end -%>
+    }
+  }
+
+  pub fn tree_inspect(&self) -> String {
+    match self {
+      <%- kinds.each do |kind| -%>
+      <%= enum_name %>::<%= kind %>(n) => n.tree_inspect(),
+      <%- end -%>
+    }
+  }
+
+  pub fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+    match self {
+      <%- kinds.each do |kind| -%>
+      <%= enum_name %>::<%= kind %>(n) => n.recursive_errors(),
+      <%- end -%>
+    }
+  }
+}
+
+<%- end -%>