herb 0.11.1 → 0.11.2

data/src/prism/ruby_parser.c

@@ -2,51 +2,51 @@
 
 #include <prism.h>
 #include <stdbool.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-static bool herb_prism_visit(const pm_node_t* node, void* data) {
+static pm_visit_result_t herb_prism_visit(const pm_node_t* node, void* data) {
   const size_t* indent = (size_t*) data;
 
   for (size_t i = 0; i < *indent * 2; i++) {
     putc(' ', stdout);
   }
 
-  printf("%s\n", pm_node_type_to_str(node->type));
+  printf("%s\n", pm_node_type(node->type));
 
   size_t next_indent = *indent + 1;
   size_t* next_data = &next_indent;
   pm_visit_child_nodes(node, herb_prism_visit, next_data);
 
-  return false;
+  return PM_VISIT_SKIP;
 }
 
 void herb_parse_ruby_to_stdout(char* source) {
   size_t length = strlen(source);
 
-  pm_parser_t parser;
-  pm_parser_init(&parser, (const uint8_t*) source, length, NULL);
+  pm_arena_t* arena = pm_arena_new();
+  pm_parser_t* parser = pm_parser_new(arena, (const uint8_t*) source, length, NULL);
 
-  pm_buffer_t buffer;
-  pm_buffer_init(&buffer);
+  pm_buffer_t* buffer = pm_buffer_new();
 
   size_t indent = 0;
-  pm_node_t* root = pm_parse(&parser);
+  pm_node_t* root = pm_parse(parser);
   size_t* data = &indent;
 
-  const char* root_type = pm_node_type_to_str(root->type);
+  const char* root_type = pm_node_type(root->type);
   printf("Root Type: %s\n", root_type);
 
   pm_visit_node(root, herb_prism_visit, data);
 
 #ifndef PRISM_EXCLUDE_PRETTYPRINT
-  pm_prettyprint(&buffer, &parser, root);
-  printf("%s\n", buffer.value);
+  pm_prettyprint(buffer, parser, root);
+  printf("%.*s\n", (int) pm_buffer_length(buffer), pm_buffer_value(buffer));
 #endif
 
-  pm_buffer_free(&buffer);
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
+  pm_buffer_free(buffer);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
 }
 
 static const char* const RUBY_FRAGMENT_PREFIXES[] = {
@@ -56,14 +56,14 @@ static const char* const RUBY_FRAGMENT_PREFIXES[] = {
 static const char* const RUBY_FRAGMENT_SUFFIXES[] = { "", "\nend", "", "\nend", "\nend", "\nend" };
 
 static bool ruby_source_parses(const char* source, size_t length) {
-  pm_parser_t parser;
-  pm_parser_init(&parser, (const uint8_t*) source, length, NULL);
+  pm_arena_t* arena = pm_arena_new();
+  pm_parser_t* parser = pm_parser_new(arena, (const uint8_t*) source, length, NULL);
 
-  pm_node_t* root = pm_parse(&parser);
-  bool parses = (parser.error_list.size == 0);
+  pm_parse(parser);
+  bool parses = (pm_parser_errors_size(parser) == 0);
 
-  if (root != NULL) { pm_node_destroy(&parser, root); }
-  pm_parser_free(&parser);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
 
   return parses;
 }

data/templates/ext/herb/nodes.c.erb

@@ -69,17 +69,17 @@ static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= nod
   <%- when Herb::Template::PrismNodeField -%>
   VALUE <%= node.human %>_<%= field.name %>;
   if (<%= node.human %>-><%= field.name %>.node != NULL && <%= node.human %>-><%= field.name %>.parser != NULL) {
-    pm_buffer_t pm_buffer = { 0 };
-    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, &pm_buffer);
+    pm_buffer_t* pm_buffer = pm_buffer_new();
+    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, pm_buffer);
 
-    if (pm_buffer.length > 0) {
-      <%= node.human %>_<%= field.name %> = rb_str_new(pm_buffer.value, pm_buffer.length);
+    if (pm_buffer_length(pm_buffer) > 0) {
+      <%= node.human %>_<%= field.name %> = rb_str_new(pm_buffer_value(pm_buffer), pm_buffer_length(pm_buffer));
       rb_enc_associate(<%= node.human %>_<%= field.name %>, rb_ascii8bit_encoding());
       OBJ_FREEZE(<%= node.human %>_<%= field.name %>);
     } else {
       <%= node.human %>_<%= field.name %> = Qnil;
     }
-    pm_buffer_free(&pm_buffer);
+    pm_buffer_free(pm_buffer);
   } else {
     <%= node.human %>_<%= field.name %> = Qnil;
   }

data/templates/ext/herb/parser_options_helpers.c.erb

@@ -1,5 +1,7 @@
 #include "parser_options_helpers.h"
 
+#include <string.h>
+
 void herb_extract_parser_options(VALUE options, parser_options_T* parser_options) {
   if (NIL_P(options)) { return; }
 <%- parser_options.extractable_fields_for(:ruby).each do |field| -%>
@@ -10,6 +12,31 @@ void herb_extract_parser_options(VALUE options, parser_options_T* parser_options
     if (NIL_P(value)) { value = rb_hash_lookup(options, ID2SYM(rb_intern("<%= field.snake_case %>"))); }
     if (!NIL_P(value)) { parser_options-><%= field.c_name %> = RTEST(value); }
   }
+<%- elsif field.string? -%>
+  {
+    VALUE value = rb_hash_lookup(options, rb_utf8_str_new_cstr("<%= field.snake_case %>"));
+    if (NIL_P(value)) { value = rb_hash_lookup(options, ID2SYM(rb_intern("<%= field.snake_case %>"))); }
+
+    if (!NIL_P(value)) {
+      Check_Type(value, T_STRING);
+
+      const char* data = RSTRING_PTR(value);
+      size_t length = (size_t) RSTRING_LEN(value);
+
+<%- if field.validator -%>
+      if (!<%= field.validator %>(data, length)) {
+        rb_raise(rb_eArgError, "<%= field.snake_case %> %+" PRIsVALUE " is not supported", value);
+      }
+<%- else -%>
+      if (length >= HERB_PARSER_OPTIONS_STRING_CAPACITY) {
+        rb_raise(rb_eArgError, "<%= field.snake_case %> must be shorter than %d bytes", HERB_PARSER_OPTIONS_STRING_CAPACITY);
+      }
+<%- end -%>
+
+      memcpy(parser_options-><%= field.c_name %>, data, length);
+      parser_options-><%= field.c_name %>[length] = '\0';
+    }
+  }
 <%- elsif field.ruby_unit == "seconds" -%>
   {
     VALUE value = rb_hash_lookup(options, rb_utf8_str_new_cstr("<%= field.snake_case %>"));
@@ -52,6 +79,12 @@ VALUE herb_build_parser_options_hash(const parser_options_T* options) {
 
     rb_hash_aset(kwargs, ID2SYM(rb_intern("<%= field.snake_case %>")), <%= field.snake_case %>);
   }
+<%- elsif field.string? -%>
+  rb_hash_aset(
+    kwargs,
+    ID2SYM(rb_intern("<%= field.snake_case %>")),
+    options-><%= field.c_name %>[0] == '\0' ? Qnil : rb_utf8_str_new_cstr(options-><%= field.c_name %>)
+  );
 <%- elsif field.ruby_unit == "seconds" -%>
   rb_hash_aset(kwargs, ID2SYM(rb_intern("<%= field.snake_case %>")), DBL2NUM((double) options-><%= field.c_name %> / 1000.0));
 <%- elsif field.nullable? -%>

data/templates/java/nodes.c.erb

@@ -49,15 +49,15 @@ jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= no
   <%- elsif field.is_a?(Herb::Template::PrismNodeField) -%>
   jbyteArray <%= field.name %>;
   if (<%= node.human %>-><%= field.name %>.node != NULL && <%= node.human %>-><%= field.name %>.parser != NULL) {
-    pm_buffer_t pm_buffer = { 0 };
-    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, &pm_buffer);
-    if (pm_buffer.length > 0) {
-      <%= field.name %> = (*env)->NewByteArray(env, (jsize)pm_buffer.length);
-      (*env)->SetByteArrayRegion(env, <%= field.name %>, 0, (jsize)pm_buffer.length, (const jbyte*)pm_buffer.value);
+    pm_buffer_t* pm_buffer = pm_buffer_new();
+    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, pm_buffer);
+    if (pm_buffer_length(pm_buffer) > 0) {
+      <%= field.name %> = (*env)->NewByteArray(env, (jsize)pm_buffer_length(pm_buffer));
+      (*env)->SetByteArrayRegion(env, <%= field.name %>, 0, (jsize)pm_buffer_length(pm_buffer), (const jbyte*)pm_buffer_value(pm_buffer));
     } else {
       <%= field.name %> = NULL;
     }
-    pm_buffer_free(&pm_buffer);
+    pm_buffer_free(pm_buffer);
   } else {
     <%= field.name %> = NULL;
   }

data/templates/java/parser_options_helpers.c.erb

@@ -1,7 +1,10 @@
 #include "parser_options_helpers.h"
 
-void herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T* parser_options) {
-  if (options == NULL) { return; }
+#include <stdio.h>
+#include <string.h>
+
+bool herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T* parser_options) {
+  if (options == NULL) { return true; }
 
   jclass optionsClass = (*env)->GetObjectClass(env, options);
 <%- parser_options.extractable_fields_for(:java).each do |field| -%>
@@ -15,6 +18,40 @@ void herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T*
       parser_options-><%= field.c_name %> = (value == JNI_TRUE);
     }
   }
+<%- elsif field.string? -%>
+  {
+    jmethodID method = (*env)->GetMethodID(env, optionsClass, "<%= field.java_getter %>", "<%= field.java_jni_signature %>");
+
+    if (method != NULL) {
+      jstring value = (jstring) (*env)->CallObjectMethod(env, options, method);
+
+      if (value != NULL) {
+        const char* string = (*env)->GetStringUTFChars(env, value, NULL);
+        size_t length = strlen(string);
+
+<%- if field.validator -%>
+        if (!<%= field.validator %>(string, length)) {
+          char message[96];
+          snprintf(message, sizeof(message), "<%= field.snake_case %> \"%.32s\" is not supported", string);
+          (*env)->ReleaseStringUTFChars(env, value, string);
+          (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"), message);
+
+          return false;
+        }
+<%- else -%>
+        if (length >= HERB_PARSER_OPTIONS_STRING_CAPACITY) {
+          (*env)->ReleaseStringUTFChars(env, value, string);
+          (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/IllegalArgumentException"), "<%= field.snake_case %> is too long");
+
+          return false;
+        }
+<%- end -%>
+
+        memcpy(parser_options-><%= field.c_name %>, string, length + 1);
+        (*env)->ReleaseStringUTFChars(env, value, string);
+      }
+    }
+  }
 <%- elsif field.nullable? -%>
   {
     jmethodID method = (*env)->GetMethodID(env, optionsClass, "<%= field.java_getter %>", "<%= field.java_jni_signature %>");
@@ -42,4 +79,6 @@ void herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T*
   }
 <%- end -%>
 <%- end -%>
+
+  return true;
 }

data/templates/java/parser_options_helpers.h.erb

@@ -4,7 +4,8 @@
 #include "../src/include/parser/parser_options.h"
 
 #include <jni.h>
+#include <stdbool.h>
 
-void herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T* parser_options);
+bool herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T* parser_options);
 
 #endif

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

@@ -89,17 +89,17 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
   <%- when Herb::Template::PrismNodeField -%>
   napi_value <%= field.name %>;
   if (<%= node.human %>-><%= field.name %>.node != NULL && <%= node.human %>-><%= field.name %>.parser != NULL) {
-    pm_buffer_t pm_buffer = { 0 };
-    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, &pm_buffer);
+    pm_buffer_t* pm_buffer = pm_buffer_new();
+    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, pm_buffer);
 
-    if (pm_buffer.length > 0) {
+    if (pm_buffer_length(pm_buffer) > 0) {
       void* buffer_data;
-      napi_create_buffer_copy(env, pm_buffer.length, pm_buffer.value, &buffer_data, &<%= field.name %>);
+      napi_create_buffer_copy(env, pm_buffer_length(pm_buffer), pm_buffer_value(pm_buffer), &buffer_data, &<%= field.name %>);
     } else {
       napi_get_null(env, &<%= field.name %>);
     }
 
-    pm_buffer_free(&pm_buffer);
+    pm_buffer_free(pm_buffer);
   } else {
     napi_get_null(env, &<%= field.name %>);
   }

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

@@ -1,10 +1,13 @@
 #include "parser_options_helpers.h"
 
-void herb_extract_parser_options(napi_env env, napi_value options, parser_options_T* parser_options) {
+#include <cstring>
+#include <string>
+
+bool herb_extract_parser_options(napi_env env, napi_value options, parser_options_T* parser_options) {
   napi_valuetype valuetype;
   napi_typeof(env, options, &valuetype);
 
-  if (valuetype != napi_object) { return; }
+  if (valuetype != napi_object) { return true; }
 <%- parser_options.extractable_fields_for(:javascript).each do |field| -%>
 
   {
@@ -19,6 +22,33 @@ void herb_extract_parser_options(napi_env env, napi_value options, parser_option
       bool value = false;
       napi_get_value_bool(env, property, &value);
       parser_options-><%= field.c_name %> = value;
+<%- elsif field.string? -%>
+      napi_valuetype property_type;
+      napi_typeof(env, property, &property_type);
+
+      if (property_type == napi_string) {
+        size_t length = 0;
+        napi_get_value_string_utf8(env, property, nullptr, 0, &length);
+
+        std::string value(length, '\0');
+        napi_get_value_string_utf8(env, property, &value[0], length + 1, &length);
+        value.resize(length);
+
+<%- if field.validator -%>
+        if (!<%= field.validator %>(value.c_str(), value.length())) {
+          std::string message = "<%= field.snake_case %> \"" + value + "\" is not supported";
+          napi_throw_error(env, nullptr, message.c_str());
+          return false;
+        }
+<%- else -%>
+        if (value.length() >= HERB_PARSER_OPTIONS_STRING_CAPACITY) {
+          napi_throw_error(env, nullptr, "<%= field.snake_case %> is too long");
+          return false;
+        }
+<%- end -%>
+
+        memcpy(parser_options-><%= field.c_name %>, value.c_str(), value.length() + 1);
+      }
 <%- elsif field.nullable? -%>
       napi_valuetype property_type;
       napi_typeof(env, property, &property_type);
@@ -38,4 +68,6 @@ void herb_extract_parser_options(napi_env env, napi_value options, parser_option
     }
   }
 <%- end -%>
+
+  return true;
 }

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

@@ -7,6 +7,6 @@ extern "C" {
 #include "../extension/libherb/include/parser/parser_options.h"
 }
 
-void herb_extract_parser_options(napi_env env, napi_value options, parser_options_T* parser_options);
+bool herb_extract_parser_options(napi_env env, napi_value options, parser_options_T* parser_options);
 
 #endif

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

@@ -15,7 +15,7 @@ module Herb
     <%- end -%>
     end
 
-    #: () -> Hash[Symbol, (bool | Numeric | Array[String] | nil)]
+    #: () -> Hash[Symbol, (bool | Numeric | String | Array[String] | nil)]
     def to_h
       {
       <%- parser_options.fields_for(:ruby).each do |field| -%>

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

@@ -1,55 +1,21 @@
-fn read_node_body(buffer: &mut SerializationBuffer, type_id: u8, pool: usize, node: &mut PrismNode) {
+fn read_node_body(
+  buffer: &mut SerializationBuffer,
+  type_id: u8,
+  pool: usize,
+  node: &mut PrismNode,
+  stack: &mut Vec<Option<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 "node", "node?" -%>
+    <%- when "node[]" -%>
+      let <%= field.name %>_count = buffer.read_var_int();
   <%- when "string" -%>
     <%- if field.name == "unescaped" -%>
       node.unescaped = Some(buffer.read_string_field(flags));
@@ -93,12 +59,92 @@ fn read_node_body(buffer: &mut SerializationBuffer, type_id: u8, pool: usize, no
       <%- raise "unhandled prism field type: #{field.type}" -%>
     <%- end -%>
   <%- end -%>
+
+    <%- prism_node.fields.reverse.each do |field| -%>
+    <%- case field.type -%>
+    <%- when "node", "node?" -%>
+      let <%= field.name %>_child = stack.pop().flatten();
+    <%- when "node[]" -%>
+      let <%= field.name %>_children = stack.split_off(stack.len().saturating_sub(<%= field.name %>_count));
+    <%- end -%>
+  <%- end -%>
+
+    <%- prism_node.fields.each do |field| -%>
+    <%- case field.type -%>
+    <%- when "node", "node?" -%>
+      if let Some(child) = <%= field.name %>_child {
+        node.children.push(child);
+      <%- if field.name == "block" && field.type == "node?" -%>
+        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 -%>
+      }
+
+    <%- when "node[]" -%>
+      node.children.extend(<%= field.name %>_children.into_iter().flatten());
+
+    <%- end -%>
+  <%- end -%>
     }
 <%- end -%>
     _ => {}
   }
 }
 
+fn record_child_count(buffer: &mut SerializationBuffer, type_id: u8, pool: usize) -> usize {
+  #[allow(unused_mut)]
+  let mut count = 0;
+
+  match type_id {
+  <%- prism_nodes.each do |prism_node| -%>
+    <%= prism_node.type_id %> => {
+      buffer.read_var_int();
+
+    <%- prism_node.fields.each do |field| -%>
+    <%- case field.type -%>
+    <%- when "node", "node?" -%>
+      count += 1;
+    <%- when "node[]" -%>
+      count += buffer.read_var_int();
+    <%- when "string" -%>
+      buffer.read_string_field(0);
+    <%- when "constant" -%>
+      buffer.read_required_constant(pool);
+    <%- when "constant?" -%>
+      buffer.read_optional_constant(pool);
+    <%- when "constant[]" -%>
+      for _ in 0..buffer.read_var_int() {
+        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 -%>
+    _ => {}
+  }
+
+  count
+}
+
 fn node_type_name_for(type_id: u8) -> String {
   match type_id {
     <%- prism_nodes.each do |prism_node| -%>

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

@@ -8,14 +8,12 @@ fn prettyprint_body(
   start_offset: usize,
   end_offset: usize,
   newlines: &[usize],
+  children: &mut std::vec::IntoIter<Option<PrismRecord>>,
 ) {
   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)));
@@ -45,29 +43,18 @@ fn prettyprint_body(
 
         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", "node?" -%>
+      match children.next().flatten() {
+        None => output.push_str(" nil\n"),
+        Some(child) => {
+          output.push('\n');
+          let saved = prefix.len();
+          prefix.push_str("<%= preadd %>");
+          let copy = prefix.clone();
+          output.push_str(&copy);
+          prettyprint_record(child, buffer, pool, output, prefix, newlines);
+          prefix.truncate(saved);
+        }
       }
   <%- when "node[]" -%>
       {
@@ -81,7 +68,11 @@ fn prettyprint_body(
           output.push_str(&copy);
           output.push_str("+-- ");
           prefix.push_str(if index == count - 1 { "    " } else { "|   " });
-          prettyprint_node(buffer, pool, output, prefix, newlines);
+
+          if let Some(child) = children.next().flatten() {
+            prettyprint_record(child, buffer, pool, output, prefix, newlines);
+          }
+
           prefix.truncate(saved);
         }
       }