herb 0.11.0-x86-linux-gnu → 0.11.2-x86-linux-gnu

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/ast/nodes.rs.erb

@@ -233,10 +233,7 @@ pub(crate) unsafe fn convert_node(node_pointer: *const c_void, source: &std::syn
         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 %>: crate::prism::serialize(
-        (*c_node_pointer).<%= field.name %>.node,
-        (*c_node_pointer).<%= field.name %>.parser,
-      ),
+      <%= field.name %>: crate::prism::serialize((*c_node_pointer).<%= field.name %>),
       source: Some(std::sync::Arc::clone(source)),
       #[cfg(feature = "prism")]
       prism_cache: std::sync::OnceLock::new(),

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);
         }
       }

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

@@ -16,9 +16,9 @@
 bool detect_<%= helper.safe_name %>(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == <%= helper.name.length %> && strncmp((const char*) constant->start, "<%= helper.name %>", <%= helper.name.length %>) == 0;
+  return constant && pm_constant_length(constant) == <%= helper.name.length %> && strncmp((const char*) pm_constant_start(constant), "<%= helper.name %>", <%= helper.name.length %>) == 0;
 }
 <%- elsif helper.receiver_call_detect? -%>
 
@@ -29,9 +29,9 @@ bool detect_<%= helper.safe_name %>(pm_call_node_t* call_node, pm_parser_t* pars
   pm_call_node_t* receiver_node = (pm_call_node_t*) call_node->receiver;
   if (!receiver_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, receiver_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, receiver_node->name);
 
-  return constant && constant->length == 3 && strncmp((const char*) constant->start, "tag", 3) == 0;
+  return constant && pm_constant_length(constant) == 3 && strncmp((const char*) pm_constant_start(constant), "tag", 3) == 0;
 }
 <%- end -%>
 <%- end -%>
@@ -79,14 +79,17 @@ extern bool is_ruby_introspection_method(hb_string_T method_name);
 static char* extract_<%= helper.safe_name %>_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->name) { return NULL; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
   if (!constant) { return NULL; }
 
-  if (is_ruby_introspection_method(hb_string_from_data((const char*) constant->start, constant->length))) { return NULL; }
+  const char* constant_start = (const char*) pm_constant_start(constant);
+  size_t constant_length = pm_constant_length(constant);
 
-  char* name = hb_allocator_strndup(allocator, (const char*) constant->start, constant->length);
+  if (is_ruby_introspection_method(hb_string_from_data(constant_start, constant_length))) { return NULL; }
 
-  for (size_t i = 0; i < constant->length && name[i] != '\0'; i++) {
+  char* name = hb_allocator_strndup(allocator, constant_start, constant_length);
+
+  for (size_t i = 0; i < constant_length && name[i] != '\0'; i++) {
     if (name[i] == '_') { name[i] = '-'; }
   }
 
@@ -111,9 +114,7 @@ static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* _call_node,
 }
 <%- elsif content.first_arg? -%>
 
-static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node, pm_parser_t* _parser, hb_allocator_T* allocator) {
-  (void) _parser;
-
+static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->arguments) { return NULL; }
 
   pm_arguments_node_t* arguments = call_node->arguments;
@@ -131,27 +132,26 @@ static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node,
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = first_argument->location.end - first_argument->location.start;
-  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+  const uint8_t* source = pm_parser_start(parser);
+  size_t source_length = first_argument->location.length;
+  return hb_allocator_strndup(allocator, (const char*) (source + first_argument->location.start), source_length);
 }
 <%- elsif content.block_or_arg? -%>
 
-static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node, pm_parser_t* <%= helper.receiver_call_detect? ? "parser" : "_parser" %>, hb_allocator_T* allocator) {
-  (void) <%= helper.receiver_call_detect? ? "parser" : "_parser" %>;
-
+static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node) { return NULL; }
 
   <%- if helper.receiver_call_detect? -%>
   if (call_node->name) {
-    pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+    const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-    if (constant && is_ruby_introspection_method(hb_string_from_data((const char*) constant->start, constant->length))) {
+    if (constant && is_ruby_introspection_method(hb_string_from_data((const char*) pm_constant_start(constant), pm_constant_length(constant)))) {
       return NULL;
     }
   }
   <%- end -%>
 
-  char* block_content = extract_inline_block_content(call_node, allocator);
+  char* block_content = extract_inline_block_content(call_node, parser, allocator);
   if (block_content) { return block_content; }
 
   <%- arg_index = (content.arg_position || 1) - 1 -%>
@@ -173,7 +173,8 @@ static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node,
           return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
         }
 
-        size_t source_length = argument->location.end - argument->location.start;
+        const uint8_t* source = pm_parser_start(parser);
+        size_t source_length = argument->location.length;
 
         <%- if content.to_s_suffix_when_single -%>
         if (arguments->arguments.size == 1 && argument->type != PM_NIL_NODE) {
@@ -182,7 +183,7 @@ static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node,
           size_t total_length = source_length + suffix_length;
           char* ruby_expression = hb_allocator_alloc(allocator, total_length + 1);
 
-          memcpy(ruby_expression, (const char*) argument->location.start, source_length);
+          memcpy(ruby_expression, (const char*) (source + argument->location.start), source_length);
           memcpy(ruby_expression + source_length, suffix, suffix_length);
           ruby_expression[total_length] = '\0';
 
@@ -190,7 +191,7 @@ static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node,
         }
         <%- end -%>
 
-        return hb_allocator_strndup(allocator, (const char*) argument->location.start, source_length);
+        return hb_allocator_strndup(allocator, (const char*) (source + argument->location.start), source_length);
 
       <%- if content.skip_if_hash -%>
       }

data/templates/src/include/parser/parser_options.h.erb

@@ -7,9 +7,15 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#define HERB_PARSER_OPTIONS_STRING_CAPACITY 16
+
 typedef struct PARSER_OPTIONS_STRUCT {
 <%- parser_options.all_c_fields.each do |field| -%>
+<%- if field.string? -%>
+  char <%= field.c_name %>[HERB_PARSER_OPTIONS_STRING_CAPACITY];
+<%- else -%>
   <%= field.c_type %> <%= field.c_name %>;
+<%- end -%>
 <%- if field.string_array? -%>
   size_t <%= field.count_name %>;
 <%- end -%>
@@ -17,5 +23,9 @@ typedef struct PARSER_OPTIONS_STRUCT {
 } parser_options_T;
 
 extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
+<%- parser_options.all_c_fields.select(&:validator).each do |field| -%>
+
+bool <%= field.validator %>(const char* value, size_t length);
+<%- end -%>
 
 #endif

data/templates/src/include/prism_version.h.erb

@@ -0,0 +1,17 @@
+<%-
+  lockfile = File.expand_path("../../../Gemfile.lock", __dir__)
+  prism_git = File.exist?(lockfile) ? File.read(lockfile).split(/\n\n+/).find { |block| block.start_with?("GIT") && block.match?(/^\s+prism \(/) } : nil
+  prism_revision = prism_git && !prism_git.match?(/^\s+tag:/) ? prism_git[/^\s+revision: (\h{7})/, 1] : nil
+-%>
+#ifndef HERB_PRISM_VERSION_H
+#define HERB_PRISM_VERSION_H
+
+#include <prism/version.h>
+
+<%- if prism_revision -%>
+#define HERB_PRISM_VERSION PRISM_VERSION "+<%= prism_revision %>"
+<%- else -%>
+#define HERB_PRISM_VERSION PRISM_VERSION
+<%- end -%>
+
+#endif

data/templates/src/parser_options_defaults.c.erb

@@ -2,7 +2,7 @@
 
 #include <stddef.h>
 
-<%- entries = parser_options.all_c_fields.flat_map { |field| field.string_array? ? [[field.c_name, "NULL"], [field.count_name, "0"]] : [[field.c_name, field.pointer? ? "NULL" : field.c_default.to_s]] } -%>
+<%- entries = parser_options.all_c_fields.flat_map { |field| field.string_array? ? [[field.c_name, "NULL"], [field.count_name, "0"]] : field.string? ? [[field.c_name, field.default ? field.default.inspect : "{ 0 }"]] : [[field.c_name, field.pointer? ? "NULL" : field.c_default.to_s]] } -%>
 <%- prefix = "const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { " -%>
 <%- entries.each_with_index do |(name, value), index| -%>
 <%= index.zero? ? prefix : " " * prefix.length %>.<%= name %> = <%= value %><%= index < entries.length - 1 ? "," : " };" %>

data/templates/template.rb

@@ -1176,7 +1176,8 @@ module Herb
     end
 
     class ParserOptionField
-      attr_reader :name, :type, :default, :description, :c_name, :nullable, :null_sentinel, :ruby_unit, :default_ms, :count_name
+      attr_reader :name, :type, :default, :description, :c_name, :nullable, :null_sentinel, :ruby_unit, :default_ms, :count_name,
+                  :validator
 
       def initialize(config)
         @name = config.fetch("name")
@@ -1193,6 +1194,7 @@ module Herb
         @only = config["only"]
         @skip = config.fetch("skip", [])
         @lex = config.fetch("lex", false)
+        @validator = config["validator"]
       end
 
       def for?(language)
@@ -1217,6 +1219,10 @@ module Herb
         @type == "string_array"
       end
 
+      def string?
+        @type == "string"
+      end
+
       def uint64?
         @type == "uint64"
       end
@@ -1253,17 +1259,19 @@ module Herb
 
       def java_jni_signature
         return "()Z" if boolean?
+        return "()Ljava/lang/String;" if string?
         return "()Ljava/lang/Integer;" if nullable?
 
         "()I"
       end
 
       def ruby_constant?
-        !string_array?
+        !string_array? && !string?
       end
 
       def ruby_default
         return "[]" if string_array?
+        return @default.nil? ? "nil" : @default.inspect if string?
         return "nil" if nullable? && @default.nil?
 
         if @ruby_unit == "seconds" && @default_ms
@@ -1290,12 +1298,14 @@ module Herb
 
       def js_default
         return "[]" if string_array?
+        return @default.nil? ? "null" : @default.inspect if string?
         return "null" if nullable? && @default.nil?
 
         @default_ms || @default
       end
 
       def java_default
+        return @default.nil? ? "null" : @default.inspect if string?
         return "null" if nullable? && @default.nil?
 
         @default_ms || @default
@@ -1303,6 +1313,7 @@ module Herb
 
       def rust_default
         return "None" if string_array?
+        return @default.nil? ? "None" : "Some(#{@default.inspect}.to_string())" if string?
         return "None" if nullable? && @default.nil?
 
         value = @default_ms || @default
@@ -1322,6 +1333,7 @@ module Herb
       def ruby_type
         return "bool" if boolean?
         return "Array[String]" if string_array?
+        return "String?" if string?
         return "Numeric" if @ruby_unit == "seconds"
 
         nullable? ? "Integer?" : "Integer"
@@ -1330,12 +1342,14 @@ module Herb
       def typescript_type
         return "boolean" if boolean?
         return "string[]" if string_array?
+        return "string | null" if string?
 
         nullable? ? "number | null" : "number"
       end
 
       def java_type
         return "boolean" if boolean?
+        return "String" if string?
 
         nullable? ? "Integer" : "int"
       end
@@ -1343,6 +1357,7 @@ module Herb
       def rust_type
         return "bool" if boolean?
         return "Option<Vec<String>>" if string_array?
+        return "Option<String>" if string?
 
         nullable? ? "Option<u32>" : "u32"
       end

data/templates/wasm/nodes.cpp.erb

@@ -47,34 +47,24 @@ val <%= node.name %>FromCStruct(<%= node.struct_type %>* <%= node.human %>, cons
   }
   <%- when Herb::Template::PrismSerializedField -%>
   if (<%= node.human %>-><%= field.name %>.data != NULL && <%= node.human %>-><%= field.name %>.length > 0) {
-    val jsArray = val::array();
-
-    for (size_t i = 0; i < <%= node.human %>-><%= field.name %>.length; i++) {
-      jsArray.call<void>("push", (int)<%= node.human %>-><%= field.name %>.data[i]);
-    }
-
-    result.set("<%= field.name %>", jsArray);
+    val view = val(typed_memory_view(<%= node.human %>-><%= field.name %>.length, (const uint8_t*) <%= node.human %>-><%= field.name %>.data));
+    result.set("<%= field.name %>", val::global("Uint8Array").new_(view));
   } else {
     result.set("<%= field.name %>", val::null());
   }
   <%- when Herb::Template::PrismNodeField -%>
   if (<%= node.human %>-><%= field.name %>.node != NULL && <%= node.human %>-><%= field.name %>.parser != NULL) {
-    pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(<%= node.human %>-><%= field.name %>.parser, <%= node.human %>-><%= field.name %>.node, &pm_buffer);
-
-    if (pm_buffer.length > 0) {
-      val jsArray = val::array();
-
-      for (size_t i = 0; i < pm_buffer.length; i++) {
-        jsArray.call<void>("push", (int)((uint8_t*)pm_buffer.value)[i]);
-      }
+    pm_buffer_t* pm_buffer = pm_buffer_new();
+    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, pm_buffer);
 
-      result.set("<%= field.name %>", jsArray);
+    if (pm_buffer_length(pm_buffer) > 0) {
+      val view = val(typed_memory_view(pm_buffer_length(pm_buffer), (const uint8_t*) pm_buffer_value(pm_buffer)));
+      result.set("<%= field.name %>", val::global("Uint8Array").new_(view));
     } else {
       result.set("<%= field.name %>", val::null());
     }
 
-    pm_buffer_free(&pm_buffer);
+    pm_buffer_free(pm_buffer);
   } else {
     result.set("<%= field.name %>", val::null());
   }