herb 0.10.4-aarch64-linux-gnu → 0.11.0-aarch64-linux-gnu

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

@@ -112,7 +112,7 @@ unsafe fn convert_location_field(location_ptr: *const location_T) -> Option<Loca
   }
 }
 
-unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec<AnyNode> {
+unsafe fn convert_children(children_array: *mut hb_array_T, source: &std::sync::Arc<str>) -> Vec<AnyNode> {
   if children_array.is_null() {
     return Vec::new();
   }
@@ -123,7 +123,7 @@ unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec<AnyNode> {
   for index in 0..count {
     let child_ptr = hb_array_get(children_array, index);
     if !child_ptr.is_null() {
-      if let Some(node) = convert_node(child_ptr as *const c_void) {
+      if let Some(node) = convert_node(child_ptr as *const c_void, source) {
         children.push(node);
       }
     }
@@ -133,16 +133,16 @@ unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec<AnyNode> {
 }
 
 #[allow(dead_code)]
-unsafe fn convert_node_field(node_pointer: *mut c_void) -> Option<Box<AnyNode>> {
+unsafe fn convert_node_field(node_pointer: *mut c_void, source: &std::sync::Arc<str>) -> Option<Box<AnyNode>> {
   if node_pointer.is_null() {
     None
   } else {
-    convert_node(node_pointer).map(Box::new)
+    convert_node(node_pointer, source).map(Box::new)
   }
 }
 
 macro_rules! convert_specific_node_field {
-  ($node_pointer:expr, $expected_type:expr, $convert_fn:ident, $node_type:ty) => {
+  ($node_pointer:expr, $expected_type:expr, $convert_fn:ident, $node_type:ty, $source:expr) => {
     if $node_pointer.is_null() {
       None
     } else {
@@ -154,13 +154,13 @@ macro_rules! convert_specific_node_field {
         eprintln!("Warning: Expected node type {} but got {}", $expected_type, node_type);
         None
       } else {
-        $convert_fn($node_pointer as *const c_void).map(Box::new)
+        $convert_fn($node_pointer as *const c_void, $source).map(Box::new)
       }
     }
   };
 }
 
-pub(crate) unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode> {
+pub(crate) unsafe fn convert_node(node_pointer: *const c_void, source: &std::sync::Arc<str>) -> Option<AnyNode> {
   if node_pointer.is_null() {
     return None;
   }
@@ -171,7 +171,7 @@ pub(crate) unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode
 
   match node_type {
     <%- nodes.each do |node| -%>
-    <%= node.type %> => convert_<%= node.human %>(node_pointer).map(|n| AnyNode::<%= node.name %>(Box::new(n))),
+    <%= node.type %> => convert_<%= node.human %>(node_pointer, source).map(|n| AnyNode::<%= node.name %>(Box::new(n))),
     <%- end -%>
     _ => {
       eprintln!("Warning: Unknown node type {}", node_type);
@@ -189,7 +189,8 @@ pub(crate) unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode
   /// 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_pointer: *const c_void) -> Option<<%= node.name %>> {
+  #[allow(unused_variables)]
+  <%= node.name == "DocumentNode" ? "pub " : "" %>unsafe fn convert_<%= node.human %>(node_pointer: *const c_void, source: &std::sync::Arc<str>) -> Option<<%= node.name %>> {
     if node_pointer.is_null() {
       return None;
     }
@@ -198,7 +199,7 @@ pub(crate) unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode
     let node_base_ref = &(*c_node_pointer).base;
 
     Some(<%= node.name %> {
-      node_type: "<%= node.name %>".to_string(),
+      node_type: "<%= node.type %>".to_string(),
       location: convert_location(node_base_ref.location),
       errors: convert_errors(node_base_ref.errors),
       <%- node.fields.each do |field| -%>
@@ -212,16 +213,16 @@ pub(crate) unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode
       <%- when Herb::Template::BooleanField -%>
       <%= field.name %>: (*c_node_pointer).<%= field.name %>,
       <%- when Herb::Template::ArrayField -%>
-      <%= field.name %>: convert_children((*c_node_pointer).<%= field.name %>),
+      <%= field.name %>: convert_children((*c_node_pointer).<%= field.name %>, source),
       <%- 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_pointer).<%= 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 %>, source),
       <%- 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),
+      <%= field.name %>: convert_<%= snake_name %>_field((*c_node_pointer).<%= field.name %> as *mut c_void, source),
       <%- else -%>
-      <%= field.name %>: convert_node_field((*c_node_pointer).<%= field.name %> as *mut c_void),
+      <%= field.name %>: convert_node_field((*c_node_pointer).<%= field.name %> as *mut c_void, source),
       <%- end -%>
       <%- when Herb::Template::LocationField -%>
       <%= field.name %>: convert_location_field((*c_node_pointer).<%= field.name %>),
@@ -232,21 +233,13 @@ pub(crate) unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode
         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
-        }
-      },
+      <%= field.name %>: crate::prism::serialize(
+        (*c_node_pointer).<%= field.name %>.node,
+        (*c_node_pointer).<%= field.name %>.parser,
+      ),
+      source: Some(std::sync::Arc::clone(source)),
+      #[cfg(feature = "prism")]
+      prism_cache: std::sync::OnceLock::new(),
       <%- when Herb::Template::AnalyzedRubyField, Herb::Template::PrismContextField -%>
       // skip internal field: <%= field.name %>
       <%- end -%>
@@ -261,7 +254,7 @@ pub(crate) unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode
   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 %>> {
+unsafe fn convert_<%= snake_name %>_field(node_pointer: *mut c_void, source: &std::sync::Arc<str>) -> Option<<%= enum_name %>> {
   if node_pointer.is_null() {
     return None;
   }
@@ -273,7 +266,7 @@ unsafe fn convert_<%= snake_name %>_field(node_pointer: *mut c_void) -> Option<<
     <%- 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)?)))
+      Some(<%= enum_name %>::<%= kind %>(Box::new(convert_<%= node.human %>(node_pointer as *const c_void, source)?)))
     }
     <%- end -%>
     _ => None,

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

@@ -1,5 +1,5 @@
 use crate::{Location, Position, Token};
-use colored::*;
+use crate::style::Colorize;
 
 fn escape_string(s: &str) -> String {
   s.replace('\\', "\\\\")

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

@@ -1,7 +1,7 @@
 use crate::errors::{AnyError, ErrorNode};
 use crate::{Location, Token};
 use crate::union_types::*;
-use colored::*;
+use crate::style::Colorize;
 
 pub(crate) fn prettify_prism_tree(input: &str) -> String {
   let input = input.replace("+-- ", "├── ").replace("|   ", "│   ");
@@ -197,6 +197,7 @@ pub trait Node {
   fn errors(&self) -> &[AnyError];
   fn child_nodes(&self) -> Vec<&dyn Node>;
   fn recursive_errors(&self) -> Vec<&dyn ErrorNode>;
+  fn collect_errors<'a>(&'a self, accumulator: &mut Vec<&'a dyn ErrorNode>);
   fn tree_inspect(&self) -> String;
 }
 
@@ -256,9 +257,15 @@ impl AnyNode {
   }
 
   pub fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+    let mut accumulator: Vec<&dyn ErrorNode> = Vec::new();
+    self.collect_errors(&mut accumulator);
+    accumulator
+  }
+
+  pub fn collect_errors<'a>(&'a self, accumulator: &mut Vec<&'a dyn ErrorNode>) {
     match self {
       <%- nodes.each do |node| -%>
-      AnyNode::<%= node.name %>(n) => n.recursive_errors(),
+      AnyNode::<%= node.name %>(n) => n.collect_errors(accumulator),
       <%- end -%>
     }
   }
@@ -285,6 +292,10 @@ impl Node for AnyNode {
     self.recursive_errors()
   }
 
+  fn collect_errors<'a>(&'a self, accumulator: &mut Vec<&'a dyn ErrorNode>) {
+    self.collect_errors(accumulator)
+  }
+
   fn tree_inspect(&self) -> String {
     self.tree_inspect()
   }
@@ -321,13 +332,35 @@ pub struct <%= node.name %> {
   <%- when Herb::Template::PrismSerializedField -%>
   pub <%= field.name %>: Option<Vec<u8>>,
   <%- when Herb::Template::PrismNodeField -%>
-  pub <%= field.name %>: Option<String>,
+  pub <%= field.name %>: Option<Vec<u8>>,
+  pub source: Option<std::sync::Arc<str>>,
+  #[cfg(feature = "prism")]
+  pub prism_cache: std::sync::OnceLock<Option<crate::prism::PrismNode>>,
   <%- when Herb::Template::AnalyzedRubyField, Herb::Template::PrismContextField -%>
   // no-op for <%= field.name %>
   <%- end -%>
   <%- end -%>
 }
 
+<%- if node.fields.any? { |field| field.is_a?(Herb::Template::PrismNodeField) } -%>
+impl <%= node.name %> {
+  <%- node.fields.select { |field| field.is_a?(Herb::Template::PrismNodeField) }.each do |field| -%>
+  #[cfg(feature = "prism")]
+  pub fn prism(&self) -> Option<&crate::prism::PrismNode> {
+    self
+      .prism_cache
+      .get_or_init(|| {
+        let bytes = self.<%= field.name %>.as_ref()?;
+        let source = self.source.as_ref()?;
+
+        crate::prism::deserialize(bytes, source)
+      })
+      .as_ref()
+  }
+  <%- end -%>
+}
+
+<%- end -%>
 impl Node for <%= node.name %> {
   fn node_type(&self) -> &str {
     &self.node_type
@@ -377,37 +410,25 @@ impl Node for <%= node.name %> {
   }
 
   fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
-    <%- has_children = node.fields.any? { |field|
-      case field
-      when Herb::Template::ArrayField
-        true
-      when Herb::Template::BorrowedNodeField, 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));
+    let mut accumulator: Vec<&dyn ErrorNode> = Vec::new();
+    self.collect_errors(&mut accumulator);
+    accumulator
+  }
 
+  fn collect_errors<'a>(&'a self, accumulator: &mut Vec<&'a dyn ErrorNode>) {
+    accumulator.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());
+      child.collect_errors(accumulator);
     }
     <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
     if let Some(ref node) = self.<%= field.name %> {
-      all_errors.extend(node.recursive_errors());
+      node.collect_errors(accumulator);
     }
     <%- end -%>
     <%- end -%>
-
-    all_errors
-    <%- else -%>
-    self.errors.iter().map(|e| e as &dyn ErrorNode).collect()
-    <%- end -%>
   }
 
   fn tree_inspect(&self) -> String {
@@ -428,11 +449,22 @@ impl Node for <%= node.name %> {
     <%- 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 %> {
+    if let Some(ref prism_bytes) = 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);
+
+      #[cfg(feature = "prism")]
+      let rendered = self
+        .source
+        .as_ref()
+        .and_then(|source| crate::prism::prettyprint(prism_bytes, source))
+        .unwrap_or_else(|| format!("({} bytes)", prism_bytes.len()));
+
+      #[cfg(not(feature = "prism"))]
+      let rendered = format!("({} bytes)", prism_bytes.len());
+
+      let prettified = prettify_prism_tree(&rendered);
       let indented = prettified.lines().enumerate().map(|(i, line)| {
         if i == 0 { line.to_string() } else { format!("{}    {}", prefix, line) }
       }).collect::<Vec<_>>().join("\n");
@@ -507,7 +539,7 @@ impl Node for <%= node.name %> {
   }
 }
 
-<%- if node.name.start_with?("ERB") -%>
+<%- if node.erb_tag? -%>
 impl ERBNode for <%= node.name %> {
   fn tag_opening(&self) -> &Option<Token> {
     &self.tag_opening

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

@@ -0,0 +1,16 @@
+#[derive(Debug, Clone)]
+pub struct ParserOptions {
+  <%- parser_options.fields_for(:rust).each do |field| -%>
+  pub <%= field.snake_case %>: <%= field.rust_type %>,
+  <%- end -%>
+}
+
+impl Default for ParserOptions {
+  fn default() -> Self {
+    Self {
+      <%- parser_options.fields_for(:rust).each do |field| -%>
+      <%= field.snake_case %>: <%= field.rust_default %>,
+      <%- end -%>
+    }
+  }
+}

data/templates/rust/src/prism/generated_deserialize.rs.erb

@@ -0,0 +1,109 @@
+fn read_node_body(buffer: &mut SerializationBuffer, type_id: u8, pool: usize, node: &mut PrismNode) {
+  match type_id {
+  <%- prism_nodes.each do |prism_node| -%>
+    <%= prism_node.type_id %> => {
+      <%- if prism_node.name == "DefNode" -%>
+      buffer.read_uint32();
+      <%- end -%>
+
+      let flags = buffer.read_var_int() as u32;
+      node.flags = flags;
+
+    <%- prism_node.fields.each do |field| -%>
+    <%- case field.type -%>
+    <%- when "node" -%>
+      {
+        let child = read_node(buffer, pool);
+        node.children.push(child);
+      }
+
+      <%- if field.name == "receiver" -%>
+        node.receiver_index = Some(node.children.len() - 1);
+      <%- elsif prism_node.name == "AssocNode" && field.name == "key" -%>
+        node.key = Some(Box::new(node.children[node.children.len() - 1].clone()));
+      <%- end -%>
+
+    <%- when "node?" -%>
+      if buffer.peek_byte() != 0 {
+        let child = read_node(buffer, pool);
+        node.children.push(child);
+      <%- if field.name == "block" -%>
+        node.has_block = true;
+      <%- end -%>
+
+      <%- if field.name == "receiver" -%>
+        node.receiver_index = Some(node.children.len() - 1);
+      <%- elsif prism_node.name == "AssocNode" && field.name == "key" -%>
+        node.key = Some(Box::new(node.children[node.children.len() - 1].clone()));
+      <%- end -%>
+
+      } else {
+        buffer.read_byte();
+      }
+  <%- when "node[]" -%>
+      {
+        let count = buffer.read_var_int();
+
+        for _ in 0..count {
+          let child = read_node(buffer, pool);
+          node.children.push(child);
+        }
+      }
+
+  <%- when "string" -%>
+    <%- if field.name == "unescaped" -%>
+      node.unescaped = Some(buffer.read_string_field(flags));
+    <%- else -%>
+      buffer.read_string_field(flags);
+    <%- end -%>
+  <%- when "constant" -%>
+    <%- if field.name == "name" -%>
+      node.name = Some(buffer.read_required_constant(pool));
+    <%- else -%>
+      buffer.read_required_constant(pool);
+    <%- end -%>
+  <%- when "constant?" -%>
+    <%- if field.name == "name" -%>
+      node.name = buffer.read_optional_constant(pool);
+    <%- else -%>
+      buffer.read_optional_constant(pool);
+    <%- end -%>
+  <%- when "constant[]" -%>
+      {
+        let count = buffer.read_var_int();
+
+        for _ in 0..count {
+          buffer.read_required_constant(pool);
+        }
+      }
+    <%- when "location" -%>
+      buffer.read_location();
+    <%- when "location?" -%>
+      buffer.read_optional_location();
+    <%- when "uint8" -%>
+      buffer.read_byte();
+    <%- when "uint32" -%>
+      buffer.read_var_int();
+    <%- when "integer" -%>
+      buffer.read_integer();
+    <%- when "double" -%>
+      buffer.read_double();
+    <%- when "flags" -%>
+    <%- else -%>
+      <%- raise "unhandled prism field type: #{field.type}" -%>
+    <%- end -%>
+  <%- end -%>
+    }
+<%- end -%>
+    _ => {}
+  }
+}
+
+fn node_type_name_for(type_id: u8) -> String {
+  match type_id {
+    <%- prism_nodes.each do |prism_node| -%>
+      <%= prism_node.type_id %> => "<%= prism_node.name %>".to_string(),
+    <%- end -%>
+    _ => "Unknown".to_string(),
+  }
+}

data/templates/rust/src/prism/generated_prettyprint.rs.erb

@@ -0,0 +1,153 @@
+#[allow(clippy::too_many_arguments)]
+fn prettyprint_body(
+  buffer: &mut SerializationBuffer,
+  type_id: u8,
+  pool: usize,
+  output: &mut String,
+  prefix: &mut String,
+  start_offset: usize,
+  end_offset: usize,
+  newlines: &[usize],
+) {
+  match type_id {
+<%- prism_nodes.each do |prism_node| -%>
+  <%- entries = prism_node.entries -%>
+    <%= prism_node.type_id %> => {
+    <%- if prism_node.name == "DefNode" -%>
+      buffer.read_uint32();
+    <%- end -%>
+      #[allow(unused_variables)]
+      let flags = buffer.read_var_int() as u32;
+      output.push_str(&format!("@ <%= prism_node.name %> (location: {})\n", location_string(start_offset, end_offset, newlines)));
+  <%- entries.each_with_index do |field, position| -%>
+    <%- preadd = position == entries.size - 1 ? "    " : "|   " -%>
+      output.push_str(prefix);
+      output.push_str("+-- <%= field.name %>:");
+
+  <%- case field.type -%>
+  <%- when "__flags" -%>
+      {
+        let mut found = false;
+      <%- (prism_flags[field.name] || []).each_with_index do |value, bit| -%>
+        if flags & (1 << <%= bit + 2 %>) != 0 {
+          if found {
+            output.push(',');
+          }
+
+          output.push_str(" <%= value.downcase %>");
+          found = true;
+        }
+      <%- end -%>
+
+        if !found {
+          output.push_str(" nil");
+        }
+
+        output.push('\n');
+      }
+  <%- when "node" -%>
+      output.push('\n');
+
+      {
+        let saved = prefix.len();
+        prefix.push_str("<%= preadd %>");
+        let copy = prefix.clone();
+        output.push_str(&copy);
+        prettyprint_node(buffer, pool, output, prefix, newlines);
+        prefix.truncate(saved);
+      }
+  <%- when "node?" -%>
+      if buffer.peek_byte() == 0 {
+        buffer.read_byte();
+        output.push_str(" nil\n");
+      } else {
+        output.push('\n');
+        let saved = prefix.len();
+        prefix.push_str("<%= preadd %>");
+        let copy = prefix.clone();
+        output.push_str(&copy);
+        prettyprint_node(buffer, pool, output, prefix, newlines);
+        prefix.truncate(saved);
+      }
+  <%- when "node[]" -%>
+      {
+        let count = buffer.read_var_int();
+        output.push_str(&format!(" (length: {count})\n"));
+
+        for index in 0..count {
+          let saved = prefix.len();
+          prefix.push_str("<%= preadd %>");
+          let copy = prefix.clone();
+          output.push_str(&copy);
+          output.push_str("+-- ");
+          prefix.push_str(if index == count - 1 { "    " } else { "|   " });
+          prettyprint_node(buffer, pool, output, prefix, newlines);
+          prefix.truncate(saved);
+        }
+      }
+  <%- when "string" -%>
+      {
+        let value = buffer.read_string_field(0);
+        output.push_str(&format!(" \"{}\"\n", crate::prism::buffer::escape_ruby(value.as_bytes())));
+      }
+  <%- when "constant" -%>
+      output.push_str(&format!(" :{}\n", buffer.read_required_constant(pool)));
+  <%- when "constant?" -%>
+      match buffer.read_optional_constant(pool) {
+        Some(name) => output.push_str(&format!(" :{name}\n")),
+        None => output.push_str(" nil\n"),
+      }
+  <%- when "constant[]" -%>
+      {
+        let count = buffer.read_var_int();
+        output.push_str(" [");
+
+        for index in 0..count {
+          if index != 0 {
+            output.push_str(", ");
+          }
+
+          output.push_str(&format!(":{}", buffer.read_required_constant(pool)));
+        }
+
+        output.push_str("]\n");
+      }
+
+  <%- when "location" -%>
+      {
+        let (start, length) = buffer.read_location();
+
+        output.push_str(&format!(
+          " {} = \"{}\"\n",
+          location_string(start, start + length, newlines),
+          crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
+        ));
+      }
+
+  <%- when "location?" -%>
+      match buffer.read_optional_location() {
+        None => output.push_str(" nil\n"),
+        Some((start, length)) => output.push_str(&format!(
+          " {} = \"{}\"\n",
+          location_string(start, start + length, newlines),
+          crate::prism::buffer::escape_ruby(buffer.source_slice(start, length))
+        )),
+      }
+
+  <%- when "uint8" -%>
+      output.push_str(&format!(" {}\n", buffer.read_byte()));
+  <%- when "uint32" -%>
+      output.push_str(&format!(" {}\n", buffer.read_var_int()));
+  <%- when "integer" -%>
+      output.push_str(&format!(" {}\n", buffer.read_integer_string()));
+  <%- when "double" -%>
+      output.push_str(&format!(" {:.6}\n", buffer.read_double()));
+  <%- else -%>
+    <%- raise "unhandled prism field type in prettyprint: #{field.type}" -%>
+  <%- end -%>
+<%- end -%>
+    }
+<%- end -%>
+    _ => {}
+  }
+}

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

@@ -49,9 +49,15 @@ impl <%= enum_name %> {
   }
 
   pub fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+    let mut accumulator: Vec<&dyn ErrorNode> = Vec::new();
+    self.collect_errors(&mut accumulator);
+    accumulator
+  }
+
+  pub fn collect_errors<'a>(&'a self, accumulator: &mut Vec<&'a dyn ErrorNode>) {
     match self {
       <%- kinds.each do |kind| -%>
-      <%= enum_name %>::<%= kind %>(n) => n.recursive_errors(),
+      <%= enum_name %>::<%= kind %>(n) => n.collect_errors(accumulator),
       <%- end -%>
     }
   }

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

@@ -30,7 +30,7 @@ pub trait Visitor {
 
   <%- nodes.each do |node| -%>
   fn visit_<%= node.human %>(&mut self, node: &<%= node.name %>) {
-    <%- if node.name.start_with?("ERB") -%>
+    <%- if node.erb_tag? -%>
     self.visit_erb_node(node);
     <%- end -%>
     self.walk_<%= node.human %>(node);

data/templates/src/analyze/action_view/helper_registry.c.erb

@@ -16,6 +16,16 @@ static const helper_implicit_attribute_T <%= helper.safe_name %>_implicit_attrib
   .wrapper = "<%= helper.implicit_attribute.wrapper %>",
 };
 
+<%- end -%>
+<%- if helper.content? -%>
+static const helper_content_T <%= helper.safe_name %>_content = {
+  .source = "<%= helper.content.source %>",
+  .arg_position = <%= helper.content.arg_position || -1 %>,
+  .skip_if_hash = <%= helper.content.skip_if_hash %>,
+  .to_s_suffix_when_single = <%= helper.content.to_s_suffix_when_single %>,
+  .positional_arguments_with_block = <%= helper.content.positional_arguments_with_block || -1 %>,
+};
+
 <%- end -%>
 <%- if helper.arguments.any? -%>
 static const helper_argument_T <%= helper.safe_name %>_arguments[] = {
@@ -32,6 +42,14 @@ static const helper_option_T <%= helper.safe_name %>_options[] = {
 <%- end -%>
 };
 
+<%- end -%>
+<%- if helper.block_arguments.any? -%>
+static const helper_block_argument_T <%= helper.safe_name %>_block_arguments[] = {
+<%- helper.block_arguments.each do |arg| -%>
+  { .name = "<%= arg.name %>", .type = "<%= arg.type_display %>", .optional = <%= arg.optional %>, .description = "<%= arg.escaped_description %>" },
+<%- end -%>
+};
+
 <%- end -%>
 <%- end -%>
 static const helper_registry_entry_T registry_entries[HELPER_COUNT] = {
@@ -44,6 +62,7 @@ static const helper_registry_entry_T registry_entries[HELPER_COUNT] = {
     .gem = "<%= helper.gem %>",
     .output = HELPER_OUTPUT_<%= helper.output.upcase %>,
     .visibility = "<%= helper.visibility %>",
+    .receiver = "<%= helper.receiver %>",
     .tag_name = <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "NULL" %>,
     .is_void = <%= helper.void? %>,
     .supports_block = <%= helper.supports_block %>,
@@ -54,10 +73,13 @@ static const helper_registry_entry_T registry_entries[HELPER_COUNT] = {
     .signature = "<%= helper.escaped_signature %>",
     .documentation_url = "<%= helper.documentation_url %>",
     .implicit_attribute = <%= helper.implicit_attribute? ? "&#{helper.safe_name}_implicit_attribute" : "NULL" %>,
+    .content = <%= helper.content? ? "&#{helper.safe_name}_content" : "NULL" %>,
     .arguments = <%= helper.arguments.any? ? "#{helper.safe_name}_arguments" : "NULL" %>,
     .arguments_count = <%= helper.arguments.size %>,
     .options = <%= helper.options.any? ? "#{helper.safe_name}_options" : "NULL" %>,
     .options_count = <%= helper.options.size %>,
+    .block_arguments = <%= helper.block_arguments.any? ? "#{helper.safe_name}_block_arguments" : "NULL" %>,
+    .block_arguments_count = <%= helper.block_arguments.size %>,
   },
 <%- end -%>
 };