herb 0.7.4-aarch64-linux-gnu → 0.8.0-aarch64-linux-gnu

data/templates/java/org/herb/ast/Errors.java.erb

@@ -0,0 +1,121 @@
+package org.herb.ast;
+
+import org.herb.Location;
+import org.herb.Token;
+
+/**
+ * Base class for all Herb parsing errors.
+ */
+abstract class HerbError {
+  private final String type;
+  private final String message;
+  private final Location location;
+
+  public HerbError(String type, String message, Location location) {
+    this.type = type;
+    this.message = message;
+    this.location = location;
+  }
+
+  public String getType() {
+    return type;
+  }
+
+  public String getMessage() {
+    return message;
+  }
+
+  public Location getLocation() {
+    return location;
+  }
+
+  @Override
+  public String toString() {
+    return String.format("HerbError{type='%s', message='%s', location=%s}", type, message, location);
+  }
+
+  public abstract String inspect();
+
+  protected String indent(String str, int level) {
+    if (level == 0) return str;
+    String prefix = "    ".repeat(level);
+    return str.lines()
+              .map(line -> prefix + line)
+              .collect(java.util.stream.Collectors.joining("\n"));
+  }
+}
+
+<%- errors.each do |error| -%>
+/**
+ * <%= error.name %>: <%= error.message_template %>
+ */
+class <%= error.name %> extends HerbError {
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  private final String <%= field.name %>;
+  <%- when Herb::Template::TokenField -%>
+  private final Token <%= field.name %>;
+  <%- when Herb::Template::TokenTypeField -%>
+  private final String <%= field.name %>;
+  <%- else -%>
+  // Unsupported field type: <%= field.class %>
+  <%- end -%>
+  <%- end -%>
+
+  public <%= error.name %>(String type, String message, Location location<%- error.fields.each do |field| -%><%- case field -%><%- when Herb::Template::StringField -%>, String <%= field.name %><%- when Herb::Template::TokenField -%>, Token <%= field.name %><%- when Herb::Template::TokenTypeField -%>, String <%= field.name %><%- end -%><%- end -%>) {
+    super(type, message, location);
+    <%- error.fields.each do |field| -%>
+    this.<%= field.name %> = <%= field.name %>;
+    <%- end -%>
+  }
+
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  public String get<%= field.name.capitalize %>() {
+    return <%= field.name %>;
+  }
+
+  <%- when Herb::Template::TokenField -%>
+  public Token get<%= field.name.capitalize %>() {
+    return <%= field.name %>;
+  }
+
+  <%- when Herb::Template::TokenTypeField -%>
+  public String get<%= field.name.capitalize %>() {
+    return <%= field.name %>;
+  }
+
+  <%- end -%>
+  <%- end -%>
+  @Override
+  public String inspect() {
+    StringBuilder output = new StringBuilder();
+
+    output.append("@ <%= error.name %> ");
+    output.append(getLocation() != null ? "(location: " + getLocation().toString() + ")" : "no-location");
+    output.append("\n");
+    <%- symbol = error.fields.any? ? "├──" : "└──" -%>
+    output.append("<%= symbol %> message: ");
+    output.append("\"").append(getMessage()).append("\"");
+    output.append("\n");
+    <%- error.fields.each do |field| -%>
+    <%- symbol = error.fields.last == field ? "└──" : "├──" -%>
+    <%- case field -%>
+    <%- when Herb::Template::StringField, Herb::Template::TokenTypeField -%>
+    output.append("<%= symbol %> <%= field.name %>: ");
+    output.append("\"").append(<%= field.name %>).append("\"");
+    output.append("\n");
+    <%- when Herb::Template::TokenField -%>
+    output.append("<%= symbol %> <%= field.name %>: ");
+    output.append(<%= field.name %> != null ? <%= field.name %>.inspect() : "∅");
+    output.append("\n");
+    <%- end -%>
+    <%- end -%>
+
+    return output.toString();
+  }
+}
+
+<%- end -%>

data/templates/java/org/herb/ast/NodeVisitor.java.erb

@@ -0,0 +1,14 @@
+package org.herb.ast;
+
+/**
+ * Visitor interface for traversing AST nodes.
+ *
+ * @param <R> the return type
+ * @param <C> the context type
+ */
+public interface NodeVisitor<R, C> {
+  R visitNode(Node node, C context);
+  <%- nodes.each do |node| -%>
+  R visit<%= node.name %>(<%=node.name %> node, C context);
+  <%- end -%>
+}

data/templates/java/org/herb/ast/Nodes.java.erb

@@ -0,0 +1,220 @@
+package org.herb.ast;
+
+import org.herb.Location;
+import org.herb.Token;
+
+import java.util.ArrayList;
+import java.util.List;
+
+<%- nodes.each do |node| -%>
+class <%= node.name %> extends BaseNode {
+  <%- if node.fields.any? -%>
+  <%- node.fields.each do |field| -%>
+  <%- if field.is_a?(Herb::Template::StringField) -%>
+  private final String <%= field.name %>;
+  <%- elsif field.is_a?(Herb::Template::TokenField) -%>
+  private final Token <%= field.name %>;
+  <%- elsif field.is_a?(Herb::Template::BooleanField) -%>
+  private final boolean <%= field.name %>;
+  <%- elsif field.is_a?(Herb::Template::ArrayField) -%>
+  private final List<Node> <%= field.name %>;
+  <%- elsif field.is_a?(Herb::Template::NodeField) -%>
+  <%- if field.specific_kind -%>
+  private final <%= field.specific_kind %> <%= field.name %>;
+  <%- else -%>
+  private final Node <%= field.name %>;
+  <%- end -%>
+  <%- elsif field.is_a?(Herb::Template::ElementSourceField) -%>
+  private final String <%= field.name %>;
+  <%- else -%>
+  // private final Object <%= field.name %>;
+  <%- end -%>
+  <%- end -%>
+  <%- end -%>
+
+  public <%= node.name %>(
+    String type,
+    Location location,
+    List<Node> errors<%- if node.fields.any? %>,<% end %>
+    <%- if node.fields.any? -%>
+    <%- node.fields.each do |field| -%>
+    <%- if field.is_a?(Herb::Template::StringField) -%>
+    String <%= field.name %><%- if node.fields.last != field %>,<% end %>
+    <%- elsif field.is_a?(Herb::Template::TokenField) -%>
+    Token <%= field.name %><%- if node.fields.last != field %>,<% end %>
+    <%- elsif field.is_a?(Herb::Template::BooleanField) -%>
+    boolean <%= field.name %><%- if node.fields.last != field %>,<% end %>
+    <%- elsif field.is_a?(Herb::Template::ArrayField) -%>
+    List<Node> <%= field.name %><%- if node.fields.last != field %>,<% end %>
+    <%- elsif field.is_a?(Herb::Template::NodeField) -%>
+    <%= field.specific_kind || 'Node' %> <%= field.name %><%- if node.fields.last != field %>,<% end %>
+    <%- elsif field.is_a?(Herb::Template::ElementSourceField) -%>
+    String <%= field.name %><%- if node.fields.last != field %>,<% end %>
+    <%- else -%>
+    // <%= field.c_type %> <%= field.name %>
+    <%- end -%>
+    <%- end -%>
+    <%- end -%>
+  ) {
+    super(type, location, errors);
+
+    <%- if node.fields.any? -%>
+    <%- node.fields.each do |field| -%>
+    <%- unless field.is_a?(Herb::Template::AnalyzedRubyField) || field.is_a?(Herb::Template::PrismNodeField) -%>
+    this.<%= field.name %> = <%= field.name %>;
+    <%- else -%>
+    // this.<%= field.name %> = <%= field.name %>;
+    <%- end -%>
+    <%- end -%>
+    <%- end -%>
+  }
+
+  <%- if node.fields.any? -%>
+  <%- node.fields.each do |field| -%>
+  <%- if field.is_a?(Herb::Template::StringField) -%>
+  public String get<%= field.name.split('_').map(&:capitalize).join %>() {
+    return <%= field.name %>;
+  }
+
+  <%- elsif field.is_a?(Herb::Template::TokenField) -%>
+  public Token get<%= field.name.split('_').map(&:capitalize).join %>() {
+    return <%= field.name %>;
+  }
+
+  <%- elsif field.is_a?(Herb::Template::BooleanField) -%>
+  public boolean is<%= field.name.split('_').map(&:capitalize).join %>() {
+    return <%= field.name %>;
+  }
+
+  <%- elsif field.is_a?(Herb::Template::ArrayField) -%>
+  public List<Node> get<%= field.name.split('_').map(&:capitalize).join %>() {
+    return <%= field.name %>;
+  }
+
+  <%- elsif field.is_a?(Herb::Template::NodeField) -%>
+  public <%= field.specific_kind || 'Node' %> get<%= field.name.split('_').map(&:capitalize).join %>() {
+    return <%= field.name %>;
+  }
+
+  <%- elsif field.is_a?(Herb::Template::ElementSourceField) -%>
+  public String get<%= field.name.split('_').map(&:capitalize).join %>() {
+    return <%= field.name %>;
+  }
+
+  <%- else -%>
+  /*
+  public Object get<%= field.name.split('_').map(&:capitalize).join %>() {
+    return <%= field.name %>;
+  }
+  */
+
+  <%- end -%>
+  <%- end -%>
+  @Override
+  public <R, C> R accept(NodeVisitor<R, C> visitor, C context) {
+    return visitor.visit<%= node.name %>(this, context);
+  }
+
+  @Override
+  public <R, C> void visitChildren(NodeVisitor<R, C> visitor, C context) {
+    <%- if node.fields.any? -%>
+    <%- node.fields.each do |field| -%>
+    <%- if field.is_a?(Herb::Template::ArrayField) -%>
+    if (<%= field.name %> != null) {
+      for (Node child : <%= field.name %>) {
+        if (child != null) child.accept(visitor, context);
+      }
+    }
+
+    <%- elsif field.is_a?(Herb::Template::NodeField) -%>
+    if (<%= field.name %> != null) <%= field.name %>.accept(visitor, context);
+
+    <%- end -%>
+    <%- end -%>
+    <%- else -%>
+    // No children to visit
+    <%- end -%>
+  }
+
+  @Override
+  public String inspect() {
+    StringBuilder output = new StringBuilder();
+
+    output.append("@ <%= node.name %> ").append(location != null ? "(location: " + location.toString() + ")" : "no-location").append("\n");
+    <%- if node.fields.any? -%>
+    output.append(inspectErrors("│   "));
+    <%- else -%>
+    output.append(inspectErrors("    "));
+    <%- end -%>
+    <%- if node.fields.any? -%>
+    <%- node.fields.each_with_index do |field, index| -%>
+    <%- is_last = index == node.fields.length - 1 -%>
+    <%- symbol = is_last ? "└── " : "├── " -%>
+    <%- prefix = is_last ? "    " : "│   " -%>
+    <%- if field.is_a?(Herb::Template::StringField) || field.is_a?(Herb::Template::ElementSourceField) -%>
+    output.append("<%= symbol %><%= field.name %>: ").append(<%= field.name %> != null ? "\"" + <%= field.name %>.replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t").replace("\"", "\\\"") + "\"" : "∅").append("\n");
+    <%- elsif field.is_a?(Herb::Template::TokenField) -%>
+    output.append("<%= symbol %><%= field.name %>: ").append(<%= field.name %> != null ? <%= field.name %>.treeInspect() : "∅").append("\n");
+    <%- elsif field.is_a?(Herb::Template::BooleanField) -%>
+    output.append("<%= symbol %><%= field.name %>: ").append(<%= field.name %>).append("\n");
+    <%- elsif field.is_a?(Herb::Template::ArrayField) -%>
+    output.append("<%= symbol %><%= field.name %>: ").append(inspectArray(<%= field.name %>, "<%= prefix %>"));
+    <%- elsif field.is_a?(Herb::Template::NodeField) -%>
+    if (<%= field.name %> != null) {
+      output.append("<%= symbol %><%= field.name %>:\n");
+      output.append("<%= prefix %>").append(inspectNode(<%= field.name %>, "<%= prefix %>"));
+      <%- unless is_last -%>
+      output.append("<%= prefix %>").append("\n");
+      <%- end -%>
+    } else {
+      output.append("<%= symbol %><%= field.name %>: ∅\n");
+    }
+    <%- end -%>
+    <%- end -%>
+    <%- else -%>
+    output.append("└── (no fields)\n");
+    <%- end -%>
+
+    return output.toString();
+  }
+
+  @Override
+  public List<Node> recursiveErrors() {
+    List<Node> result = new ArrayList<>();
+
+    if (errors != null) {
+      result.addAll(errors);
+    }
+
+    <%- if node.fields.any? -%>
+    <%- node.fields.each do |field| -%>
+    <%- if field.is_a?(Herb::Template::ArrayField) -%>
+
+    if (<%= field.name %> != null) {
+      for (Node child : <%= field.name %>) {
+        if (child != null) {
+          result.addAll(child.recursiveErrors());
+        }
+      }
+    }
+
+    <%- elsif field.is_a?(Herb::Template::NodeField) -%>
+    if (<%= field.name %> != null) {
+      result.addAll(<%= field.name %>.recursiveErrors());
+    }
+
+    <%- end -%>
+    <%- end -%>
+    <%- end -%>
+
+    return result;
+  }
+
+  @Override
+  public String toString() {
+    return "<%= node.name %> {}";
+  }
+}
+
+<%- end -%>
+<%- end -%>

data/templates/java/org/herb/ast/Visitor.java.erb

@@ -0,0 +1,56 @@
+package org.herb.ast;
+
+import java.util.List;
+
+/**
+ * Abstract base class for node visitors that provides default implementations.
+ * Subclasses can override specific visit methods to customize behavior.
+ *
+ * @param <R> the return type
+ * @param <C> the context type
+ */
+public abstract class Visitor<R, C> implements NodeVisitor<R, C> {
+
+  /**
+   * Default visit method that can be overridden by subclasses.
+   */
+  @Override
+  public R visitNode(Node node, C context) {
+    visitChildNodes(node, context);
+
+    return null;
+  }
+
+  /**
+   * Visit all child nodes of a given node.
+   * Subclasses can call this to recursively visit children.
+   */
+  protected void visitChildNodes(Node node, C context) {
+    if (node != null) {
+      node.visitChildren(this, context);
+    }
+  }
+
+  /**
+   * Visit a list of nodes.
+   */
+  protected void visitAll(List<Node> nodes, C context) {
+    if (nodes == null) return;
+
+    for (Node node : nodes) {
+      if (node != null) node.accept(this, context);
+    }
+  }
+
+  <%- nodes.each do |node| -%>
+  /**
+   * Default implementation for <%= node.name %>.
+   * Delegates to visitNode by default.
+   */
+  @Override
+  public R visit<%= node.name %>(<%= node.name %> node, C context) {
+    return visitNode(node, context);
+  }
+
+  <%- end -%>
+}

data/templates/javascript/packages/core/src/visitor.ts.erb

@@ -1,11 +1,27 @@
 import {
   Node,
+  ERBNode,
   <%- nodes.each do |node| -%>
   <%= node.name %>,
   <%- end -%>
 } from "./nodes.js"
 
-export class Visitor {
+/**
+ * Interface that enforces all node visit methods are implemented
+ * This ensures that any class implementing IVisitor must have a visit method for every node type
+ */
+export interface IVisitor {
+  visit(node: Node | null | undefined): void
+  visitAll(nodes: (Node | null | undefined)[]): void
+  visitChildNodes(node: Node): void
+  <%- nodes.each do |node| -%>
+  visit<%= node.name %>(node: <%= node.name %>): void
+  <%- end -%>
+  visitNode(node: Node): void
+  visitERBNode(node: ERBNode): void
+}
+
+export class Visitor implements IVisitor {
   visit(node: Node | null | undefined): void {
     if (!node) return
 
@@ -20,8 +36,20 @@ export class Visitor {
     node.compactChildNodes().forEach(node => node.accept(this))
   }
 
+  visitNode(_node: Node): void {
+    // Default implementation does nothing
+  }
+
+  visitERBNode(_node: ERBNode): void {
+    // Default implementation does nothing
+  }
+
   <%- nodes.each do |node| -%>
   visit<%= node.name %>(node: <%= node.name %>): void {
+    this.visitNode(node)
+    <%- if node.name.start_with?("ERB") -%>
+    this.visitERBNode(node)
+    <%- end -%>
     this.visitChildNodes(node)
   }
 

data/templates/javascript/packages/node/extension/error_helpers.cpp.erb

@@ -4,16 +4,16 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../extension/libherb/include/herb.h"
-#include "../extension/libherb/include/token.h"
-#include "../extension/libherb/include/array.h"
-#include "../extension/libherb/include/errors.h"
 #include "../extension/libherb/include/ast_node.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/errors.h"
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
 }
 
 napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array);
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- errors.each do |error| -%>
 napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>* <%= error.human %>) {
@@ -75,13 +75,13 @@ napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>*
 
 <%- end -%>
 
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array) {
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_value result;
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      ERROR_T* error = (ERROR_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*) hb_array_get(array, i);
       if (error) {
         napi_value js_error = ErrorFromCStruct(env, error);
         napi_set_element(env, result, i, js_error);

data/templates/javascript/packages/node/extension/error_helpers.h.erb

@@ -8,7 +8,7 @@ extern "C" {
 }
 
 napi_value ErrorFromCStruct(napi_env env, ERROR_T* error);
-napi_value ErrorsArrayFromCArray(napi_env env, array_T* array);
+napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- errors.each do |error| -%>
 napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>* <%= error.human %>);

data/templates/javascript/packages/node/extension/nodes.cpp.erb

@@ -4,15 +4,15 @@
 #include "nodes.h"
 
 extern "C" {
-#include "../extension/libherb/include/herb.h"
-#include "../extension/libherb/include/token.h"
-#include "../extension/libherb/include/array.h"
 #include "../extension/libherb/include/ast_node.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/token.h"
+#include "../extension/libherb/include/util/hb_array.h"
 }
 
 napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
-napi_value NodesArrayFromCArray(napi_env env, array_T* array);
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>) {
@@ -25,7 +25,7 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
   napi_value result;
   napi_create_object(env, &result);
 
-  napi_value type = CreateString(env, ast_node_type_to_string(&<%= node.human %>->base));
+  napi_value type = CreateStringFromHbString(env, ast_node_type_to_string(&<%= node.human %>->base));
   napi_set_named_property(env, result, "type", type);
 
   napi_value location = CreateLocation(env, <%= node.human %>->base.location);
@@ -58,7 +58,7 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::ElementSourceField -%>
-  napi_value <%= field.name %> = CreateString(env, element_source_to_string(<%= node.human %>-><%= field.name %>));
+  napi_value <%= field.name %> = CreateStringFromHbString(env, element_source_to_string(<%= node.human %>-><%= field.name %>));
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- else -%>
@@ -73,13 +73,13 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
 }
 <%- end -%>
 
-napi_value NodesArrayFromCArray(napi_env env, array_T* array) {
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_value result;
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array_size(array); i++) {
-      AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+    for (size_t i = 0; i < hb_array_size(array); i++) {
+      AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
       if (child_node) {
         napi_value js_child = NodeFromCStruct(env, child_node);
         napi_set_element(env, result, i, js_child);

data/templates/javascript/packages/node/extension/nodes.h.erb

@@ -8,7 +8,7 @@ extern "C" {
 }
 
 napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node);
-napi_value NodesArrayFromCArray(napi_env env, array_T* array);
+napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array);
 
 <%- nodes.each do |node| -%>
 napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %>* <%= node.human %>);

data/templates/lib/herb/ast/nodes.rb.erb

@@ -2,6 +2,8 @@ module Herb
   module AST
     <%- nodes.each do |node| -%>
     class <%= node.name -%> < Node
+      include Colors
+
       <%- node.fields.each do |field| -%>
       attr_reader :<%= field.name %> #: <%= field.ruby_type %>
       <%- end -%>
@@ -55,38 +57,42 @@ module Herb
         tree_inspect.rstrip.gsub(/\s+$/, "")
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 10)
         output = +""
 
-        output += "@ #{node_name} "
-        output += location.tree_inspect
+        output += white("@ #{bold(yellow(node_name.to_s))} #{dimmed("(location: #{location.tree_inspect})")}")
         output += "\n"
 
+        if depth >= depth_limit
+          output += dimmed("└── [depth limit reached ...]\n\n")
+
+          return output.gsub(/^/, "    " * indent)
+        end
+
         output += inspect_errors(prefix: "<%= node.fields.any? ? "│   " : "    " %>")
 
         <%- node.fields.each do |field| -%>
         <%- symbol = node.fields.last == field ? "└──" : "├──" -%>
-        <%- name = "#{symbol} #{field.name}: " -%>
         <%- case field -%>
         <%- when Herb::Template::StringField -%>
-        output += %(<%= name %>#{<%= field.name %>.inspect}\n)
+        output += white("<%= symbol %> <%= field.name %>: ") + green("#{<%= field.name %>.inspect}\n")
         <%- when Herb::Template::TokenField -%>
-        output += "<%= name %>"
-        output += <%= field.name %> ? <%= field.name %>.tree_inspect : "∅"
+        output += white("<%= symbol %> <%= field.name %>: ")
+        output += <%= field.name %> ? <%= field.name %>.tree_inspect : magenta("∅")
         output += "\n"
         <%- when Herb::Template::BooleanField -%>
-        output += "<%= name %>"
-        output += [true, false].include?(<%= field.name %>) ? <%= field.name %>.to_s : "∅"
+        output += white("<%= symbol %> <%= field.name %>: ")
+        output += [true, false].include?(<%= field.name %>) ? bold(magenta(<%= field.name %>.to_s)) : magenta("∅")
         output += "\n"
         <%- when Herb::Template::ElementSourceField -%>
-        output += %(<%= name %>#{<%= field.name %>.inspect}\n)
+        output += white("<%= symbol %> <%= field.name %>: #{green(<%= field.name %>.inspect)}\n")
         <%- when Herb::Template::PrismNodeField -%>
         # no-op for <%= field.name %>
         <%- when Herb::Template::AnalyzedRubyField -%>
         # no-op for <%= field.name %>
         <%- when Herb::Template::NodeField -%>
-        output += "<%= name %>"
+        output += white("<%= symbol %> <%= field.name %>: ")
         if <%= field.name %>
           <%- prefix = (node.fields.last == field) ? "    " : "│   " -%>
           output += "\n"
@@ -95,13 +101,19 @@ module Herb
           <%- else -%>
           output += "│   └── "
           <%- end -%>
-          output += <%= field.name %>.tree_inspect(indent).gsub(/^/, "    " * (indent + 1)).lstrip.gsub(/^/, "<%= prefix %>").delete_prefix("<%= prefix %>")
+          output += <%= field.name %>.tree_inspect(indent: indent, depth: depth + 1, depth_limit: depth_limit).gsub(/^/, "    " * (indent + 1)).lstrip.gsub(/^/, "<%= prefix %>").delete_prefix("<%= prefix %>")
+          <%- if false -%>
+          <%- unless node.fields.last == field -%>
+          output += "\n"
+          output += white("<%= prefix %>\n")
+          <%- end -%>
+          <%- end -%>
         else
-          output += "∅\n"
+          output += magenta("∅\n")
         end
         <%- when Herb::Template::ArrayField -%>
-        output += "<%= name %>"
-        output += inspect_array(<%= field.name %>, prefix: "<%= (node.fields.last == field) ? "    " : "│   " %>")
+        output += white("<%= symbol %> <%= field.name %>: ")
+        output += inspect_array(<%= field.name %>, prefix: "<%= (node.fields.last == field) ? "    " : "│   " %>", indent: indent, depth: depth + 1, depth_limit: depth_limit)
         <%- else -%>
         <%- raise "Unhandled type: #{field.class}" -%>
         <%- end -%>