herb 0.8.7 → 0.8.8

data/src/include/ast_nodes.h

@@ -183,6 +183,7 @@ typedef struct AST_ERB_IF_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  location_T* then_keyword;
   hb_array_T* statements;
   struct AST_NODE_STRUCT* subsequent;
   struct AST_ERB_END_NODE_STRUCT* end_node;
@@ -202,6 +203,7 @@ typedef struct AST_ERB_WHEN_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  location_T* then_keyword;
   hb_array_T* statements;
 } AST_ERB_WHEN_NODE_T;
 
@@ -288,6 +290,7 @@ typedef struct AST_ERB_UNLESS_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  location_T* then_keyword;
   hb_array_T* statements;
   struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
   struct AST_ERB_END_NODE_STRUCT* end_node;
@@ -305,6 +308,7 @@ typedef struct AST_ERB_IN_NODE_STRUCT {
   token_T* tag_opening;
   token_T* content;
   token_T* tag_closing;
+  location_T* then_keyword;
   hb_array_T* statements;
 } AST_ERB_IN_NODE_T;
 
@@ -325,9 +329,9 @@ AST_WHITESPACE_NODE_T* ast_whitespace_node_init(token_T* value, position_T start
 AST_ERB_CONTENT_NODE_T* ast_erb_content_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, bool parsed, bool valid, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_END_NODE_T* ast_erb_end_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_ELSE_NODE_T* ast_erb_else_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors);
-AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_NODE_STRUCT* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
+AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, struct AST_NODE_STRUCT* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* body, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
-AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors);
+AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* children, hb_array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_CASE_MATCH_NODE_T* ast_erb_case_match_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* children, hb_array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_WHILE_NODE_T* ast_erb_while_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
@@ -336,9 +340,9 @@ AST_ERB_FOR_NODE_T* ast_erb_for_node_init(token_T* tag_opening, token_T* content
 AST_ERB_RESCUE_NODE_T* ast_erb_rescue_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* subsequent, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_ENSURE_NODE_T* ast_erb_ensure_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
-AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
+AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors);
 AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors);
-AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors);
+AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors);
 
 hb_string_T ast_node_type_to_string(AST_NODE_T* node);
 hb_string_T ast_node_human_type(AST_NODE_T* node);

data/src/include/location.h

@@ -19,4 +19,8 @@ void location_from(
   uint32_t end_column
 );
 
+void location_from_positions(location_T* location, position_T start, position_T end);
+
+location_T* location_create(position_T start, position_T end);
+
 #endif

data/src/include/prism_helpers.h

@@ -1,8 +1,10 @@
 #ifndef HERB_PRISM_HELPERS_H
 #define HERB_PRISM_HELPERS_H
 
+#include "analyzed_ruby.h"
 #include "ast_nodes.h"
 #include "errors.h"
+#include "location.h"
 #include "position.h"
 
 #include <prism.h>
@@ -22,4 +24,8 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
   position_T end
 );
 
+location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source);
+location_T* get_then_keyword_location_wrapped(const char* source, bool is_in_clause);
+location_T* get_then_keyword_location_elsif_wrapped(const char* source);
+
 #endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.7"
+#define HERB_VERSION "0.8.8"
 
 #endif

data/src/location.c

@@ -11,3 +11,19 @@ void location_from(
   location->start = (position_T) { .line = start_line, .column = start_column };
   location->end = (position_T) { .line = end_line, .column = end_column };
 }
+
+void location_from_positions(location_T* location, position_T start, position_T end) {
+  location->start = start;
+  location->end = end;
+}
+
+location_T* location_create(position_T start, position_T end) {
+  location_T* location = malloc(sizeof(location_T));
+
+  if (location != NULL) {
+    location->start = start;
+    location->end = end;
+  }
+
+  return location;
+}

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/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;

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

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/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 %>);

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 -%>

data/templates/rust/src/ast/nodes.rs.erb

@@ -105,6 +105,14 @@ unsafe fn convert_token_field(token_ptr: *mut token_T) -> Option<crate::Token> {
   }
 }
 
+unsafe fn convert_location_field(location_ptr: *const location_T) -> Option<Location> {
+  if location_ptr.is_null() {
+    None
+  } else {
+    Some(convert_location(*location_ptr))
+  }
+}
+
 unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec<AnyNode> {
   if children_array.is_null() {
     return Vec::new();
@@ -212,6 +220,8 @@ unsafe fn convert_node(node_ptr: *const c_void) -> Option<AnyNode> {
       <%- else -%>
       <%= field.name %>: convert_node_field((*c_node_ptr).<%= field.name %> as *mut c_void),
       <%- end -%>
+      <%- when Herb::Template::LocationField -%>
+      <%= field.name %>: convert_location_field((*c_node_ptr).<%= field.name %>),
       <%- end -%>
       <%- end -%>
     })

data/templates/rust/src/nodes.rs.erb

@@ -253,6 +253,8 @@ pub struct <%= node.name %> {
   <%- end -%>
   <%- when Herb::Template::ElementSourceField -%>
   pub <%= field.name %>: String,
+  <%- when Herb::Template::LocationField -%>
+  pub <%= field.name %>: Option<Location>,
   <%- end -%>
   <%- end -%>
 }
@@ -361,6 +363,8 @@ impl Node for <%= node.name %> {
     output.push_str(&format!("{}{}: {}", "<%= symbol %>".white(), "<%= field.name %>".white(), format_array_value(&self.<%= field.name %>, &"<%= is_last ? "    " : "│   " %>".white().to_string())));
     <%- when Herb::Template::NodeField -%>
     output.push_str(&format!("{}{}: {}", "<%= symbol %>".white(), "<%= field.name %>".white(), format_node_value(&self.<%= field.name %>, &"<%= is_last ? "    " : "│   " %>".white().to_string(), <%= !is_last %>)));
+    <%- when Herb::Template::LocationField -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), self.<%= field.name %>.as_ref().map(|l| format!("(location: {})", l).dimmed().to_string()).unwrap_or_else(|| "∅".magenta().to_string())));
     <%- end -%>
     <%- end -%>
     <%- else -%>

data/templates/src/ast_nodes.c.erb

@@ -40,6 +40,8 @@
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::VoidPointerField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::LocationField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>
@@ -123,6 +125,8 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
   free(<%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::BooleanField -%>
   <%- when Herb::Template::ElementSourceField -%>
+  <%- when Herb::Template::LocationField -%>
+  if (<%= node.human %>-><%= field.name %> != NULL) { free(<%= node.human %>-><%= field.name %>); }
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>

data/templates/src/ast_pretty_print.c.erb

@@ -87,6 +87,20 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
       hb_buffer_append(buffer, " ?\n");
 
+      <%- when Herb::Template::LocationField -%>
+      pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
+      if (<%= node.human %>-><%= field.name %>) {
+        char <%= field.name %>_location_string[128];
+        sprintf(<%= field.name %>_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          <%= node.human %>-><%= field.name %>->start.line,
+          <%= node.human %>-><%= field.name %>->start.column,
+          <%= node.human %>-><%= field.name %>->end.line,
+          <%= node.human %>-><%= field.name %>->end.column);
+        hb_buffer_append(buffer, <%= field.name %>_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       <%- else -%>
       <%= field.inspect %>
       <%- end -%>

data/templates/template.rb

@@ -117,6 +117,16 @@ module Herb
       end
     end
 
+    class LocationField < Field
+      def ruby_type
+        "Herb::Location"
+      end
+
+      def c_type
+        "location_T*"
+      end
+    end
+
     class IntegerField < Field
       def ruby_type
         "Integer"
@@ -210,6 +220,7 @@ module Herb
         when "token_type" then TokenTypeField
         when "string"     then StringField
         when "position"   then PositionField
+        when "location"   then LocationField
         when "size_t"     then SizeTField
         when "boolean"    then BooleanField
         when "prism_node" then PrismNodeField

data/templates/wasm/nodes.cpp.erb

@@ -39,6 +39,12 @@ val <%= node.name %>FromCStruct(<%= node.struct_type %>* <%= node.human %>) {
   result.set("<%= field.name %>", NodesArrayFromCArray(<%= node.human %>-><%= field.name %>));
   <%- when Herb::Template::ElementSourceField -%>
   result.set("<%= field.name %>", CreateStringFromHbString(element_source_to_string(<%= node.human %>-><%= field.name %>)));
+  <%- when Herb::Template::LocationField -%>
+  if (<%= node.human %>-><%= field.name %>) {
+    result.set("<%= field.name %>", CreateLocation(*<%= node.human %>-><%= field.name %>));
+  } else {
+    result.set("<%= field.name %>", val::null());
+  }
   <%- else -%>
   result.set("<%= field.name %>", val::null());
   <%- end -%>

data/vendor/prism/include/prism/version.h

@@ -14,7 +14,7 @@
 /**
  * The minor version of the Prism library as an int.
  */
-#define PRISM_VERSION_MINOR 7
+#define PRISM_VERSION_MINOR 8
 
 /**
  * The patch version of the Prism library as an int.
@@ -24,6 +24,6 @@
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "1.7.0"
+#define PRISM_VERSION "1.8.0"
 
 #endif