herb 0.11.0-aarch64-linux-gnu → 0.11.2-aarch64-linux-gnu

data/src/prism/prism_helpers.c

@@ -7,9 +7,47 @@
 #include "../include/location/position.h"
 
 #include <prism.h>
+#include <prism/internal/comments.h>
+#include <prism/internal/parser.h>
 #include <stdlib.h>
 #include <string.h>
 
+bool herb_ruby_version_supported(const char* value, size_t length) {
+  if (value == NULL || length == 0 || length >= HERB_PARSER_OPTIONS_STRING_CAPACITY) { return false; }
+
+  pm_options_t* options = pm_options_new();
+  bool supported = pm_options_version_set(options, value, length);
+  pm_options_free(options);
+
+  return supported;
+}
+
+void herb_prism_options_set_ruby_version(pm_options_t* options, const parser_options_T* parser_options) {
+  if (options == NULL || parser_options == NULL || parser_options->ruby_version[0] == '\0') { return; }
+
+  const char* version = parser_options->ruby_version;
+  pm_options_version_set(options, version, strnlen(version, HERB_PARSER_OPTIONS_STRING_CAPACITY));
+}
+
+pm_parser_t* herb_prism_parser_new(
+  pm_arena_t* arena,
+  const uint8_t* source,
+  size_t length,
+  const parser_options_T* parser_options
+) {
+  if (parser_options == NULL || parser_options->ruby_version[0] == '\0') {
+    return pm_parser_new(arena, source, length, NULL);
+  }
+
+  pm_options_t* options = pm_options_new();
+  herb_prism_options_set_ruby_version(options, parser_options);
+
+  pm_parser_t* parser = pm_parser_new(arena, source, length, options);
+  pm_options_free(options);
+
+  return parser;
+}
+
 hb_string_T pm_error_level_to_string(pm_error_level_t level) {
   switch (level) {
     case PM_ERROR_LEVEL_SYNTAX: return hb_string("syntax");
@@ -25,16 +63,17 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   pm_parser_t* parser,
   hb_allocator_T* allocator
 ) {
-  size_t start_offset = (size_t) (error->location.start - parser->start);
-  size_t end_offset = (size_t) (error->location.end - parser->start);
+  (void) parser;
 
-  position_T start = position_from_source_with_offset(source, start_offset);
-  position_T end = position_from_source_with_offset(source, end_offset);
+  pm_location_t location = pm_diagnostic_location(error);
+
+  position_T start = position_from_source_with_offset(source, location.start);
+  position_T end = position_from_source_with_offset(source, herb_prism_location_end(location));
 
   return ruby_parse_error_init(
-    hb_string(error->message),
-    hb_string(pm_diagnostic_id_human(error->diag_id)),
-    pm_error_level_to_string(error->level),
+    hb_string(pm_diagnostic_message(error)),
+    hb_string(pm_diagnostic_type(error)),
+    pm_error_level_to_string(pm_diagnostic_error_level(error)),
     start,
     end,
     allocator
@@ -48,9 +87,9 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
   hb_allocator_T* allocator
 ) {
   return ruby_parse_error_init(
-    hb_string(error->message),
-    hb_string(pm_diagnostic_id_human(error->diag_id)),
-    pm_error_level_to_string(error->level),
+    hb_string(pm_diagnostic_message(error)),
+    hb_string(pm_diagnostic_type(error)),
+    pm_error_level_to_string(pm_diagnostic_error_level(error)),
     start,
     end,
     allocator
@@ -62,55 +101,51 @@ typedef struct {
   bool found;
 } then_keyword_search_context_T;
 
-static bool has_pm_location(pm_location_t location) {
-  return location.start != NULL && location.end != NULL && (location.end - location.start) > 0;
-}
-
-static bool search_then_keyword_location(const pm_node_t* node, void* data) {
+static pm_visit_result_t search_then_keyword_location(const pm_node_t* node, void* data) {
   then_keyword_search_context_T* context = (then_keyword_search_context_T*) data;
 
-  if (context->found) { return false; }
+  if (context->found) { return PM_VISIT_SKIP; }
 
   switch (node->type) {
     case PM_IF_NODE: {
       const pm_if_node_t* if_node = (const pm_if_node_t*) node;
 
-      if (!has_pm_location(if_node->if_keyword_loc)) { break; }
+      if (!herb_prism_location_present(if_node->if_keyword_loc)) { break; }
 
-      if (has_pm_location(if_node->then_keyword_loc)) {
+      if (herb_prism_location_present(if_node->then_keyword_loc)) {
         context->then_keyword_loc = if_node->then_keyword_loc;
         context->found = true;
-        return false;
+        return PM_VISIT_SKIP;
       }
       break;
     }
 
     case PM_UNLESS_NODE: {
       const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
-      if (has_pm_location(unless_node->then_keyword_loc)) {
+      if (herb_prism_location_present(unless_node->then_keyword_loc)) {
         context->then_keyword_loc = unless_node->then_keyword_loc;
         context->found = true;
-        return false;
+        return PM_VISIT_SKIP;
       }
       break;
     }
 
     case PM_WHEN_NODE: {
       const pm_when_node_t* when_node = (const pm_when_node_t*) node;
-      if (has_pm_location(when_node->then_keyword_loc)) {
+      if (herb_prism_location_present(when_node->then_keyword_loc)) {
         context->then_keyword_loc = when_node->then_keyword_loc;
         context->found = true;
-        return false;
+        return PM_VISIT_SKIP;
       }
       break;
     }
 
     case PM_IN_NODE: {
       const pm_in_node_t* in_node = (const pm_in_node_t*) node;
-      if (has_pm_location(in_node->then_loc)) {
-        context->then_keyword_loc = in_node->then_loc;
+      if (herb_prism_location_present(in_node->then_keyword_loc)) {
+        context->then_keyword_loc = in_node->then_keyword_loc;
         context->found = true;
-        return false;
+        return PM_VISIT_SKIP;
       }
       break;
     }
@@ -120,23 +155,20 @@ static bool search_then_keyword_location(const pm_node_t* node, void* data) {
 
   pm_visit_child_nodes(node, search_then_keyword_location, context);
 
-  return false;
+  return PM_VISIT_SKIP;
 }
 
 location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source, hb_allocator_T* allocator) {
   if (analyzed == NULL || analyzed->root == NULL || source == NULL) { return NULL; }
 
-  then_keyword_search_context_T context = { .then_keyword_loc = { .start = NULL, .end = NULL }, .found = false };
+  then_keyword_search_context_T context = { .then_keyword_loc = { .start = 0, .length = 0 }, .found = false };
 
   pm_visit_child_nodes(analyzed->root, search_then_keyword_location, &context);
 
   if (!context.found) { return NULL; }
 
-  size_t start_offset = (size_t) (context.then_keyword_loc.start - analyzed->parser.start);
-  size_t end_offset = (size_t) (context.then_keyword_loc.end - analyzed->parser.start);
-
-  position_T start_position = position_from_source_with_offset(source, start_offset);
-  position_T end_position = position_from_source_with_offset(source, end_offset);
+  position_T start_position = position_from_source_with_offset(source, context.then_keyword_loc.start);
+  position_T end_position = position_from_source_with_offset(source, herb_prism_location_end(context.then_keyword_loc));
 
   return location_create(start_position, end_position, allocator);
 }
@@ -150,25 +182,26 @@ static location_T* parse_wrapped_and_find_then_keyword(
   size_t adjustment_amount,
   hb_allocator_T* allocator
 ) {
-  pm_parser_t parser;
-  pm_parser_init(&parser, (const uint8_t*) hb_buffer_value(buffer), hb_buffer_length(buffer), NULL);
-  pm_node_t* root = pm_parse(&parser);
+  pm_arena_t* arena = pm_arena_new();
+  pm_parser_t* parser = pm_parser_new(arena, (const uint8_t*) hb_buffer_value(buffer), hb_buffer_length(buffer), NULL);
+  pm_node_t* root = pm_parse(parser);
 
   if (root == NULL) {
-    pm_parser_free(&parser);
+    pm_parser_free(parser);
+    pm_arena_free(arena);
 
     return NULL;
   }
 
-  then_keyword_search_context_T context = { .then_keyword_loc = { .start = NULL, .end = NULL }, .found = false };
+  then_keyword_search_context_T context = { .then_keyword_loc = { .start = 0, .length = 0 }, .found = false };
 
   pm_visit_child_nodes(root, search_then_keyword_location, &context);
 
   location_T* location = NULL;
 
   if (context.found) {
-    size_t start_offset = (size_t) (context.then_keyword_loc.start - parser.start);
-    size_t end_offset = (size_t) (context.then_keyword_loc.end - parser.start);
+    size_t start_offset = context.then_keyword_loc.start;
+    size_t end_offset = herb_prism_location_end(context.then_keyword_loc);
 
     if (start_offset >= prefix_length && end_offset >= prefix_length) {
       start_offset -= prefix_length;
@@ -188,8 +221,8 @@ static location_T* parse_wrapped_and_find_then_keyword(
     }
   }
 
-  pm_node_destroy(&parser, root);
-  pm_parser_free(&parser);
+  pm_parser_free(parser);
+  pm_arena_free(arena);
 
   return location;
 }
@@ -244,3 +277,95 @@ location_T* get_then_keyword_location_elsif_wrapped(const char* source, hb_alloc
 
   return location;
 }
+
+static size_t newline_index_for_offset(const pm_line_offset_list_t* newlines, size_t offset) {
+  size_t low = 0;
+  size_t high = newlines->size;
+
+  while (low < high) {
+    size_t middle = low + (high - low) / 2;
+
+    if (newlines->offsets[middle] <= offset) {
+      low = middle + 1;
+    } else {
+      high = middle;
+    }
+  }
+
+  return low > 0 ? low - 1 : 0;
+}
+
+void herb_prism_node_serialize(herb_prism_node_T prism_node, pm_buffer_t* buffer) {
+  if (!prism_node.node || !prism_node.parser) { return; }
+
+  pm_parser_t* parser = prism_node.parser;
+
+  if (prism_node.source_end == 0 || parser->line_offsets.size == 0) {
+    pm_serialize(parser, prism_node.node, buffer);
+    return;
+  }
+
+  const pm_line_offset_list_t* newlines = &parser->line_offsets;
+  size_t first_line = newline_index_for_offset(newlines, prism_node.source_start);
+  size_t last_line = newline_index_for_offset(newlines, prism_node.source_end);
+  size_t line_count = last_line - first_line + 1;
+
+  if (last_line + 1 < newlines->size) { line_count++; }
+
+  pm_parser_t view = *parser;
+
+  view.line_offsets.offsets = newlines->offsets + first_line;
+  view.line_offsets.size = line_count;
+  view.line_offsets.capacity = line_count;
+  view.start_line = parser->start_line + (int32_t) first_line;
+
+  memset(&view.magic_comment_list, 0, sizeof(pm_list_t));
+  memset(&view.error_list, 0, sizeof(pm_list_t));
+  memset(&view.warning_list, 0, sizeof(pm_list_t));
+  memset(&view.comment_list, 0, sizeof(pm_list_t));
+  memset(&view.comment_attachments, 0, sizeof(view.comment_attachments));
+
+  size_t comment_count = 0;
+
+  for (pm_list_node_t* entry = parser->comment_list.head; entry; entry = entry->next) {
+    pm_comment_t* comment = (pm_comment_t*) entry;
+    size_t start = comment->location.start;
+
+    if (start >= prism_node.source_start && start < prism_node.source_end) { comment_count++; }
+  }
+
+  pm_comment_t* comments = NULL;
+
+  if (comment_count > 0) {
+    comments = malloc(comment_count * sizeof(pm_comment_t));
+
+    if (!comments) {
+      pm_serialize(parser, prism_node.node, buffer);
+      return;
+    }
+
+    size_t index = 0;
+
+    for (pm_list_node_t* entry = parser->comment_list.head; entry; entry = entry->next) {
+      pm_comment_t* comment = (pm_comment_t*) entry;
+      size_t start = comment->location.start;
+
+      if (start < prism_node.source_start || start >= prism_node.source_end) { continue; }
+
+      comments[index] = *comment;
+      comments[index].node.next = NULL;
+
+      if (index > 0) { comments[index - 1].node.next = &comments[index].node; }
+
+      index++;
+    }
+
+    view.comment_list.size = comment_count;
+    view.comment_list.head = &comments[0].node;
+    view.comment_list.tail = &comments[comment_count - 1].node;
+  }
+
+  pm_serialize(&view, prism_node.node, buffer);
+
+  free(comments);
+}

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 };
-    pm_serialize(<%= node.human %>-><%= field.name %>.parser, <%= node.human %>-><%= field.name %>.node, &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 };
-    pm_serialize(<%= node.human %>-><%= field.name %>.parser, <%= node.human %>-><%= field.name %>.node, &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/core/src/nodes.ts.erb

@@ -13,6 +13,26 @@ import type { LocateResult } from "./locate.js"
 
 export type SerializedNodeType = string
 
+type PrismNodeCacheEntry = {
+  bytes: Uint8Array
+  source: string
+  node: PrismNode | null
+}
+
+const prismNodeCache = new WeakMap<Node, PrismNodeCacheEntry>()
+
+function cachedPrismNode(owner: Node, bytes: Uint8Array, source: string): PrismNode | null {
+  const cached = prismNodeCache.get(owner)
+
+  if (cached && cached.bytes === bytes && cached.source === source) return cached.node
+
+  const node = deserializePrismNode(bytes, source)
+
+  prismNodeCache.set(owner, { bytes, source, node })
+
+  return node
+}
+
 export interface SerializedNode {
   type: SerializedNodeType
   location: SerializedLocation
@@ -388,7 +408,7 @@ export class <%= node.name %> extends Node {
   <%- prism_field = node.fields.find { |f| f.is_a?(Herb::Template::PrismSerializedField) || f.is_a?(Herb::Template::PrismNodeField) } -%>
   get prismNode(): PrismNode | null {
     if (!this.<%= prism_field.name %> || !this.source) return null;
-    return deserializePrismNode(this.<%= prism_field.name %>, this.source);
+    return cachedPrismNode(this, this.<%= prism_field.name %>, this.source);
   }
   <%- end -%>
 

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 };
-    pm_serialize(<%= node.human %>-><%= field.name %>.parser, <%= node.human %>-><%= field.name %>.node, &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 %>);
   }