herb 0.11.0-x86-linux-gnu → 0.11.1-x86-linux-gnu

data/src/prism/prism_helpers.c

@@ -244,3 +244,94 @@ location_T* get_then_keyword_location_elsif_wrapped(const char* source, hb_alloc
 
   return location;
 }
+
+static size_t newline_index_for_offset(const pm_newline_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->newline_list.size == 0) {
+    pm_serialize(parser, prism_node.node, buffer);
+    return;
+  }
+
+  const pm_newline_list_t* newlines = &parser->newline_list;
+  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.newline_list.offsets = newlines->offsets + first_line;
+  view.newline_list.size = line_count;
+  view.newline_list.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));
+
+  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 = (size_t) (comment->location.start - parser->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 = (size_t) (comment->location.start - parser->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/templates/ext/herb/nodes.c.erb

@@ -70,7 +70,7 @@ static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= nod
   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);
+    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);

data/templates/java/nodes.c.erb

@@ -50,7 +50,7 @@ jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= no
   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);
+    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);

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

@@ -90,7 +90,7 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
   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);
+    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, &pm_buffer);
 
     if (pm_buffer.length > 0) {
       void* buffer_data;

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/wasm/nodes.cpp.erb

@@ -47,29 +47,19 @@ 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);
+    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, &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]);
-      }
-
-      result.set("<%= field.name %>", jsArray);
+      val view = val(typed_memory_view(pm_buffer.length, (const uint8_t*) pm_buffer.value));
+      result.set("<%= field.name %>", val::global("Uint8Array").new_(view));
     } else {
       result.set("<%= field.name %>", val::null());
     }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
 platform: x86-linux-gnu
 authors:
 - Marco Roth