herb 0.8.6-x86_64-linux-gnu → 0.8.8-x86_64-linux-gnu

data/src/prism_helpers.c

@@ -1,10 +1,14 @@
 #include "include/prism_helpers.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
+#include "include/location.h"
 #include "include/position.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
 
 #include <prism.h>
+#include <stdlib.h>
+#include <string.h>
 
 const char* pm_error_level_to_string(pm_error_level_t level) {
   switch (level) {
@@ -50,3 +54,187 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
     end
   );
 }
+
+typedef struct {
+  pm_location_t then_keyword_loc;
+  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) {
+  then_keyword_search_context_T* context = (then_keyword_search_context_T*) data;
+
+  if (context->found) { return false; }
+
+  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->then_keyword_loc)) {
+        context->then_keyword_loc = if_node->then_keyword_loc;
+        context->found = true;
+        return false;
+      }
+      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)) {
+        context->then_keyword_loc = unless_node->then_keyword_loc;
+        context->found = true;
+        return false;
+      }
+      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)) {
+        context->then_keyword_loc = when_node->then_keyword_loc;
+        context->found = true;
+        return false;
+      }
+      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;
+        context->found = true;
+        return false;
+      }
+      break;
+    }
+
+    default: break;
+  }
+
+  pm_visit_child_nodes(node, search_then_keyword_location, context);
+
+  return false;
+}
+
+location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source) {
+  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 };
+
+  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);
+
+  return location_create(start_position, end_position);
+}
+
+static location_T* parse_wrapped_and_find_then_keyword(
+  hb_buffer_T* buffer,
+  const char* source,
+  size_t source_length,
+  size_t prefix_length,
+  size_t adjustment_threshold,
+  size_t adjustment_amount
+) {
+  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);
+
+  if (root == NULL) {
+    pm_parser_free(&parser);
+
+    return NULL;
+  }
+
+  then_keyword_search_context_T context = { .then_keyword_loc = { .start = NULL, .end = NULL }, .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);
+
+    if (start_offset >= prefix_length && end_offset >= prefix_length) {
+      start_offset -= prefix_length;
+      end_offset -= prefix_length;
+
+      if (start_offset > adjustment_threshold) {
+        start_offset += adjustment_amount;
+        end_offset += adjustment_amount;
+      }
+
+      if (start_offset <= source_length && end_offset <= source_length) {
+        position_T start_position = position_from_source_with_offset(source, start_offset);
+        position_T end_position = position_from_source_with_offset(source, end_offset);
+
+        location = location_create(start_position, end_position);
+      }
+    }
+  }
+
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+
+  return location;
+}
+
+location_T* get_then_keyword_location_wrapped(const char* source, bool is_in_clause) {
+  if (source == NULL) { return NULL; }
+
+  size_t source_length = strlen(source);
+
+  hb_buffer_T buffer;
+
+  if (!hb_buffer_init(&buffer, source_length + 16)) { return NULL; }
+
+  hb_buffer_append(&buffer, "case x\n");
+  size_t prefix_length = hb_buffer_length(&buffer);
+  hb_buffer_append(&buffer, source);
+  hb_buffer_append(&buffer, "\nend");
+
+  location_T* location =
+    parse_wrapped_and_find_then_keyword(&buffer, source, source_length, prefix_length, SIZE_MAX, 0);
+
+  free(buffer.value);
+
+  return location;
+}
+
+location_T* get_then_keyword_location_elsif_wrapped(const char* source) {
+  if (source == NULL) { return NULL; }
+
+  const char* elsif_position = strstr(source, "elsif");
+
+  if (elsif_position == NULL) { return NULL; }
+
+  size_t source_length = strlen(source);
+  size_t elsif_offset = (size_t) (elsif_position - source);
+  size_t replacement_diff = strlen("elsif") - strlen("if");
+
+  hb_buffer_T buffer;
+
+  if (!hb_buffer_init(&buffer, source_length + 8)) { return NULL; }
+
+  hb_buffer_append_with_length(&buffer, source, elsif_offset);
+  hb_buffer_append(&buffer, "if");
+  size_t if_end_offset = hb_buffer_length(&buffer);
+  hb_buffer_append(&buffer, source + elsif_offset + strlen("elsif"));
+  hb_buffer_append(&buffer, "\nend");
+
+  location_T* location =
+    parse_wrapped_and_find_then_keyword(&buffer, source, source_length, 0, if_end_offset, replacement_diff);
+
+  free(buffer.value);
+
+  return location;
+}

data/src/util/hb_array.c

@@ -116,6 +116,7 @@ void* hb_array_pop(hb_array_T* array) {
   return last_item;
 }
 
+// TODO: Remove this function once we fully migrate to hb_narray
 size_t hb_array_size(const hb_array_T* array) {
   if (array == NULL) { return 0; }
 

data/src/util/hb_narray.c

@@ -73,3 +73,9 @@ void hb_narray_deinit(hb_narray_T* array) {
   array->size = 0;
   free(array->items);
 }
+
+size_t hb_narray_size(const hb_narray_T* array) {
+  if (array == NULL) { return 0; }
+
+  return array->size;
+}

data/src/visitor.c

@@ -24,7 +24,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_DOCUMENT_NODE_T* document_node = ((const AST_DOCUMENT_NODE_T *) node);
 
       if (document_node->children != NULL) {
-        for (size_t index = 0; index < document_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(document_node->children); index++) {
           herb_visit_node(hb_array_get(document_node->children, index), visitor, data);
         }
       }
@@ -35,7 +35,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = ((const AST_HTML_OPEN_TAG_NODE_T *) node);
 
       if (html_open_tag_node->children != NULL) {
-        for (size_t index = 0; index < html_open_tag_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_open_tag_node->children); index++) {
           herb_visit_node(hb_array_get(html_open_tag_node->children, index), visitor, data);
         }
       }
@@ -46,7 +46,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = ((const AST_HTML_CLOSE_TAG_NODE_T *) node);
 
       if (html_close_tag_node->children != NULL) {
-        for (size_t index = 0; index < html_close_tag_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_close_tag_node->children); index++) {
           herb_visit_node(hb_array_get(html_close_tag_node->children, index), visitor, data);
         }
       }
@@ -61,7 +61,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       }
 
       if (html_element_node->body != NULL) {
-        for (size_t index = 0; index < html_element_node->body->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_element_node->body); index++) {
           herb_visit_node(hb_array_get(html_element_node->body, index), visitor, data);
         }
       }
@@ -76,7 +76,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = ((const AST_HTML_ATTRIBUTE_VALUE_NODE_T *) node);
 
       if (html_attribute_value_node->children != NULL) {
-        for (size_t index = 0; index < html_attribute_value_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_attribute_value_node->children); index++) {
           herb_visit_node(hb_array_get(html_attribute_value_node->children, index), visitor, data);
         }
       }
@@ -87,7 +87,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = ((const AST_HTML_ATTRIBUTE_NAME_NODE_T *) node);
 
       if (html_attribute_name_node->children != NULL) {
-        for (size_t index = 0; index < html_attribute_name_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_attribute_name_node->children); index++) {
           herb_visit_node(hb_array_get(html_attribute_name_node->children, index), visitor, data);
         }
       }
@@ -111,7 +111,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_COMMENT_NODE_T* html_comment_node = ((const AST_HTML_COMMENT_NODE_T *) node);
 
       if (html_comment_node->children != NULL) {
-        for (size_t index = 0; index < html_comment_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_comment_node->children); index++) {
           herb_visit_node(hb_array_get(html_comment_node->children, index), visitor, data);
         }
       }
@@ -122,7 +122,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = ((const AST_HTML_DOCTYPE_NODE_T *) node);
 
       if (html_doctype_node->children != NULL) {
-        for (size_t index = 0; index < html_doctype_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_doctype_node->children); index++) {
           herb_visit_node(hb_array_get(html_doctype_node->children, index), visitor, data);
         }
       }
@@ -133,7 +133,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_XML_DECLARATION_NODE_T* xml_declaration_node = ((const AST_XML_DECLARATION_NODE_T *) node);
 
       if (xml_declaration_node->children != NULL) {
-        for (size_t index = 0; index < xml_declaration_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(xml_declaration_node->children); index++) {
           herb_visit_node(hb_array_get(xml_declaration_node->children, index), visitor, data);
         }
       }
@@ -144,7 +144,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_CDATA_NODE_T* cdata_node = ((const AST_CDATA_NODE_T *) node);
 
       if (cdata_node->children != NULL) {
-        for (size_t index = 0; index < cdata_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(cdata_node->children); index++) {
           herb_visit_node(hb_array_get(cdata_node->children, index), visitor, data);
         }
       }
@@ -155,7 +155,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ELSE_NODE_T* erb_else_node = ((const AST_ERB_ELSE_NODE_T *) node);
 
       if (erb_else_node->statements != NULL) {
-        for (size_t index = 0; index < erb_else_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_else_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_else_node->statements, index), visitor, data);
         }
       }
@@ -166,7 +166,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IF_NODE_T* erb_if_node = ((const AST_ERB_IF_NODE_T *) node);
 
       if (erb_if_node->statements != NULL) {
-        for (size_t index = 0; index < erb_if_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_if_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_if_node->statements, index), visitor, data);
         }
       }
@@ -185,7 +185,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BLOCK_NODE_T* erb_block_node = ((const AST_ERB_BLOCK_NODE_T *) node);
 
       if (erb_block_node->body != NULL) {
-        for (size_t index = 0; index < erb_block_node->body->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_block_node->body); index++) {
           herb_visit_node(hb_array_get(erb_block_node->body, index), visitor, data);
         }
       }
@@ -200,7 +200,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHEN_NODE_T* erb_when_node = ((const AST_ERB_WHEN_NODE_T *) node);
 
       if (erb_when_node->statements != NULL) {
-        for (size_t index = 0; index < erb_when_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_when_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_when_node->statements, index), visitor, data);
         }
       }
@@ -211,13 +211,13 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_NODE_T* erb_case_node = ((const AST_ERB_CASE_NODE_T *) node);
 
       if (erb_case_node->children != NULL) {
-        for (size_t index = 0; index < erb_case_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_case_node->children); index++) {
           herb_visit_node(hb_array_get(erb_case_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_node->conditions != NULL) {
-        for (size_t index = 0; index < erb_case_node->conditions->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_case_node->conditions); index++) {
           herb_visit_node(hb_array_get(erb_case_node->conditions, index), visitor, data);
         }
       }
@@ -236,13 +236,13 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = ((const AST_ERB_CASE_MATCH_NODE_T *) node);
 
       if (erb_case_match_node->children != NULL) {
-        for (size_t index = 0; index < erb_case_match_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_case_match_node->children); index++) {
           herb_visit_node(hb_array_get(erb_case_match_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_match_node->conditions != NULL) {
-        for (size_t index = 0; index < erb_case_match_node->conditions->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_case_match_node->conditions); index++) {
           herb_visit_node(hb_array_get(erb_case_match_node->conditions, index), visitor, data);
         }
       }
@@ -261,7 +261,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHILE_NODE_T* erb_while_node = ((const AST_ERB_WHILE_NODE_T *) node);
 
       if (erb_while_node->statements != NULL) {
-        for (size_t index = 0; index < erb_while_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_while_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_while_node->statements, index), visitor, data);
         }
       }
@@ -276,7 +276,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNTIL_NODE_T* erb_until_node = ((const AST_ERB_UNTIL_NODE_T *) node);
 
       if (erb_until_node->statements != NULL) {
-        for (size_t index = 0; index < erb_until_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_until_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_until_node->statements, index), visitor, data);
         }
       }
@@ -291,7 +291,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_FOR_NODE_T* erb_for_node = ((const AST_ERB_FOR_NODE_T *) node);
 
       if (erb_for_node->statements != NULL) {
-        for (size_t index = 0; index < erb_for_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_for_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_for_node->statements, index), visitor, data);
         }
       }
@@ -306,7 +306,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_RESCUE_NODE_T* erb_rescue_node = ((const AST_ERB_RESCUE_NODE_T *) node);
 
       if (erb_rescue_node->statements != NULL) {
-        for (size_t index = 0; index < erb_rescue_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_rescue_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_rescue_node->statements, index), visitor, data);
         }
       }
@@ -321,7 +321,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ENSURE_NODE_T* erb_ensure_node = ((const AST_ERB_ENSURE_NODE_T *) node);
 
       if (erb_ensure_node->statements != NULL) {
-        for (size_t index = 0; index < erb_ensure_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_ensure_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_ensure_node->statements, index), visitor, data);
         }
       }
@@ -332,7 +332,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BEGIN_NODE_T* erb_begin_node = ((const AST_ERB_BEGIN_NODE_T *) node);
 
       if (erb_begin_node->statements != NULL) {
-        for (size_t index = 0; index < erb_begin_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_begin_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_begin_node->statements, index), visitor, data);
         }
       }
@@ -359,7 +359,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNLESS_NODE_T* erb_unless_node = ((const AST_ERB_UNLESS_NODE_T *) node);
 
       if (erb_unless_node->statements != NULL) {
-        for (size_t index = 0; index < erb_unless_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_unless_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_unless_node->statements, index), visitor, data);
         }
       }
@@ -378,7 +378,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IN_NODE_T* erb_in_node = ((const AST_ERB_IN_NODE_T *) node);
 
       if (erb_in_node->statements != NULL) {
-        for (size_t index = 0; index < erb_in_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_in_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_in_node->statements, index), visitor, data);
         }
       }

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

@@ -71,7 +71,7 @@ VALUE rb_errors_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < array->size; i++) {
+    for (size_t i = 0; i < hb_array_size(array); i++) {
       ERROR_T* child_node = (ERROR_T*) hb_array_get(array, i);
 
       if (child_node) {

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

@@ -45,6 +45,8 @@ static VALUE rb_<%= node.human %>_from_c_struct(<%= node.struct_type %>* <%= nod
     hb_string_T element_source_string = element_source_to_string(<%= node.human %>-><%= field.name %>);
     <%= node.human %>_<%= field.name %> = rb_utf8_str_new(element_source_string.data, element_source_string.length);
   }
+  <%- when Herb::Template::LocationField -%>
+  VALUE <%= node.human %>_<%= field.name %> = (<%= node.human %>-><%= field.name %> != NULL) ? rb_location_from_c_struct(*<%= node.human %>-><%= field.name %>) : Qnil;
   <%- else -%>
   /* <%= field.inspect %> */
   VALUE <%= node.human %>_<%= field.name %> = Qnil;
@@ -81,7 +83,7 @@ static VALUE rb_nodes_array_from_c_array(hb_array_T* array) {
   VALUE rb_array = rb_ary_new();
 
   if (array) {
-    for (size_t i = 0; i < array->size; 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) {

data/templates/java/error_helpers.c.erb

@@ -46,7 +46,7 @@ jobject ErrorsArrayFromCArray(JNIEnv* env, hb_array_T* array) {
   jobject javaList = (*env)->NewObject(env, arrayListClass, arrayListConstructor, 0);
 
   if (array) {
-    for (size_t i = 0; i < array->size; i++) {
+    for (size_t i = 0; i < hb_array_size(array); i++) {
       ERROR_T* error = (ERROR_T*) hb_array_get(array, i);
 
       if (error) {

data/templates/java/nodes.c.erb

@@ -37,12 +37,14 @@ jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= no
   <%- elsif field.is_a?(Herb::Template::ElementSourceField) -%>
   // TODO: Convert element_source to string
   jstring <%= field.name %> = (*env)->NewStringUTF(env, "");
+  <%- elsif field.is_a?(Herb::Template::LocationField) -%>
+  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? CreateLocation(env, *<%= node.human %>-><%= field.name %>) : NULL;
   <%- elsif field.is_a?(Herb::Template::AnalyzedRubyField) || field.is_a?(Herb::Template::PrismNodeField) -%>
   // Skip <%= field.name %> (<%= field.class.name.split('::').last %>) - not supported in Java yet
   <%- end -%>
   <%- end -%>
 
-  const char* signature = "(Ljava/lang/String;Lorg/herb/Location;Ljava/util/List;<%- node.fields.each do |f| -%><%- unless f.is_a?(Herb::Template::AnalyzedRubyField) || f.is_a?(Herb::Template::PrismNodeField) -%><%- if f.is_a?(Herb::Template::StringField) -%>Ljava/lang/String;<%- elsif f.is_a?(Herb::Template::TokenField) -%>Lorg/herb/Token;<%- elsif f.is_a?(Herb::Template::BooleanField) -%>Z<%- elsif f.is_a?(Herb::Template::ArrayField) -%>Ljava/util/List;<%- elsif f.is_a?(Herb::Template::NodeField) -%>Lorg/herb/ast/<%= f.specific_kind || 'Node' %>;<%- elsif f.is_a?(Herb::Template::ElementSourceField) -%>Ljava/lang/String;<%- end -%><%- end -%><%- end -%>)V";
+  const char* signature = "(Ljava/lang/String;Lorg/herb/Location;Ljava/util/List;<%- node.fields.each do |f| -%><%- unless f.is_a?(Herb::Template::AnalyzedRubyField) || f.is_a?(Herb::Template::PrismNodeField) -%><%- if f.is_a?(Herb::Template::StringField) -%>Ljava/lang/String;<%- elsif f.is_a?(Herb::Template::TokenField) -%>Lorg/herb/Token;<%- elsif f.is_a?(Herb::Template::BooleanField) -%>Z<%- elsif f.is_a?(Herb::Template::ArrayField) -%>Ljava/util/List;<%- elsif f.is_a?(Herb::Template::NodeField) -%>Lorg/herb/ast/<%= f.specific_kind || 'Node' %>;<%- elsif f.is_a?(Herb::Template::ElementSourceField) -%>Ljava/lang/String;<%- elsif f.is_a?(Herb::Template::LocationField) -%>Lorg/herb/Location;<%- end -%><%- end -%><%- end -%>)V";
   jmethodID constructor = (*env)->GetMethodID(env, nodeClass, "<init>", signature);
   if (!constructor) { return NULL; }
 
@@ -75,9 +77,9 @@ jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
     return (*env)->NewObject(env, arrayListClass, arrayListConstructor, 0);
   }
 
-  jobject javaList = (*env)->NewObject(env, arrayListClass, arrayListConstructor, (jint) array->size);
+  jobject javaList = (*env)->NewObject(env, arrayListClass, arrayListConstructor, (jint) hb_array_size(array));
 
-  for (size_t i = 0; i < array->size; 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) {

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

@@ -26,6 +26,8 @@ class <%= node.name %> extends BaseNode {
   <%- end -%>
   <%- elsif field.is_a?(Herb::Template::ElementSourceField) -%>
   private final String <%= field.name %>;
+  <%- elsif field.is_a?(Herb::Template::LocationField) -%>
+  private final Location <%= field.name %>;
   <%- else -%>
   // private final Object <%= field.name %>;
   <%- end -%>
@@ -50,6 +52,8 @@ class <%= node.name %> extends BaseNode {
     <%= 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 %>
+    <%- elsif field.is_a?(Herb::Template::LocationField) -%>
+    Location <%= field.name %><%- if node.fields.last != field %>,<% end %>
     <%- else -%>
     // <%= field.c_type %> <%= field.name %>
     <%- end -%>
@@ -101,6 +105,11 @@ class <%= node.name %> extends BaseNode {
     return <%= field.name %>;
   }
 
+  <%- elsif field.is_a?(Herb::Template::LocationField) -%>
+  public Location get<%= field.name.split('_').map(&:capitalize).join %>() {
+    return <%= field.name %>;
+  }
+
   <%- else -%>
   /*
   public Object get<%= field.name.split('_').map(&:capitalize).join %>() {
@@ -157,6 +166,8 @@ class <%= node.name %> extends BaseNode {
     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::LocationField) -%>
+    output.append("<%= symbol %><%= field.name %>: ").append(<%= field.name %> != null ? "(location: " + <%= field.name %>.treeInspect() + ")" : "∅").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) -%>

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

@@ -143,6 +143,8 @@ export interface Serialized<%= node.name %> extends SerializedNode {
   <%= field.name %>: boolean;
   <%- when Herb::Template::ElementSourceField -%>
   <%= field.name %>: string;
+  <%- when Herb::Template::LocationField -%>
+  <%= field.name %>: SerializedLocation | null;
   <%- when Herb::Template::NodeField -%>
   <%- if field.specific_kind -%>
   <%= field.name %>: Serialized<%= field.specific_kind %> | null;
@@ -170,6 +172,8 @@ export interface <%= node.name %>Props extends BaseNodeProps {
   <%= field.name %>: boolean;
   <%- when Herb::Template::ElementSourceField -%>
   <%= field.name %>: string;
+  <%- when Herb::Template::LocationField -%>
+  <%= field.name %>: Location | null;
   <%- when Herb::Template::NodeField -%>
   <%- if field.specific_kind -%>
   <%= field.name %>: <%= field.specific_kind %> | null;
@@ -201,6 +205,8 @@ export class <%= node.name %> extends Node {
   readonly <%= field.name %>: boolean;
   <%- when Herb::Template::ElementSourceField -%>
   readonly <%= field.name %>: string;
+  <%- when Herb::Template::LocationField -%>
+  readonly <%= field.name %>: Location | null;
   <%- when Herb::Template::NodeField -%>
   <%- if field.specific_kind -%>
   readonly <%= field.name %>: <%= field.specific_kind %> | null;
@@ -239,6 +245,8 @@ export class <%= node.name %> extends Node {
       <%= field.name %>: data.<%= field.name %>,
       <%- when Herb::Template::ElementSourceField -%>
       <%= field.name %>: data.<%= field.name %>,
+      <%- when Herb::Template::LocationField -%>
+      <%= field.name %>: data.<%= field.name %> ? Location.from(data.<%= field.name %>) : null,
       <%- when Herb::Template::NodeField -%>
       <%= field.name %>: data.<%= field.name %> ? fromSerializedNode((data.<%= field.name %>)) : null,
       <%- when Herb::Template::ArrayField -%>
@@ -268,6 +276,8 @@ export class <%= node.name %> extends Node {
     this.<%= field.name %> = props.<%= field.name %>;
     <%- when Herb::Template::ElementSourceField -%>
     this.<%= field.name %> = props.<%= field.name %>;
+    <%- when Herb::Template::LocationField -%>
+    this.<%= field.name %> = props.<%= field.name %>;
     <%- when Herb::Template::PrismNodeField, Herb::Template::AnalyzedRubyField -%>
     // no-op for <%= field.name %>
     <%- else -%>
@@ -325,6 +335,8 @@ export class <%= node.name %> extends Node {
       <%= field.name %>: this.<%= field.name %>,
       <%- when Herb::Template::ElementSourceField -%>
       <%= field.name %>: this.<%= field.name %>,
+      <%- when Herb::Template::LocationField -%>
+      <%= field.name %>: this.<%= field.name %> ? this.<%= field.name %>.toJSON() : null,
       <%- when Herb::Template::NodeField -%>
       <%= field.name %>: this.<%= field.name %> ? this.<%= field.name %>.toJSON() : null,
       <%- when Herb::Template::ArrayField -%>
@@ -355,6 +367,8 @@ export class <%= node.name %> extends Node {
     output += `<%= name %>${typeof this.<%= field.name %> === 'boolean' ? String(this.<%= field.name %>) : "∅"}\n`;
     <%- when Herb::Template::ElementSourceField -%>
     output += `<%= name %>${this.<%= field.name %> ? JSON.stringify(this.<%= field.name %>) : "∅"}\n`;
+    <%- when Herb::Template::LocationField -%>
+    output += `<%= name %>${this.<%= field.name %> ? "(location: " + this.<%= field.name %>.treeInspect() + ")" : "∅"}\n`;
     <%- when Herb::Template::NodeField -%>
     output += `<%= name %>${this.inspectNode(this.<%= field.name %>, "<%= (node.fields.last == field) ? "    " : "│   " %>")}`;
     <%- when Herb::Template::ArrayField -%>

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

@@ -80,7 +80,7 @@ napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array->size; 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);

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

@@ -61,6 +61,15 @@ napi_value <%= node.human %>NodeFromCStruct(napi_env env, <%= node.struct_type %
   napi_value <%= field.name %> = CreateStringFromHbString(env, element_source_to_string(<%= node.human %>-><%= field.name %>));
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
+  <%- when Herb::Template::LocationField -%>
+  napi_value <%= field.name %>;
+  if (<%= node.human %>-><%= field.name %> != NULL) {
+    <%= field.name %> = CreateLocation(env, *<%= node.human %>-><%= field.name %>);
+  } else {
+    napi_get_null(env, &<%= field.name %>);
+  }
+  napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
+
   <%- else -%>
   napi_value <%= field.name %>;
   napi_get_null(env, &<%= field.name %>);
@@ -78,7 +87,7 @@ napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array->size; 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);

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

@@ -85,6 +85,10 @@ module Herb
         output += white("<%= symbol %> <%= field.name %>: ")
         output += [true, false].include?(<%= field.name %>) ? bold(magenta(<%= field.name %>.to_s)) : magenta("∅")
         output += "\n"
+        <%- when Herb::Template::LocationField -%>
+        output += white("<%= symbol %> <%= field.name %>: ")
+        output += <%= field.name %> ? dimmed("(location: #{<%= field.name %>.tree_inspect})") : magenta("∅")
+        output += "\n"
         <%- when Herb::Template::ElementSourceField -%>
         output += white("<%= symbol %> <%= field.name %>: #{green(<%= field.name %>.inspect)}\n")
         <%- when Herb::Template::PrismNodeField -%>