herb 0.11.1 → 0.11.2

data/sig/herb/parser_options.rbs

@@ -28,6 +28,8 @@ module Herb
 
     attr_reader render_nodes: bool
 
+    attr_reader ruby_version: String?
+
     attr_reader strict: bool
 
     attr_reader strict_locals: bool
@@ -76,11 +78,11 @@ module Herb
 
     DEFAULT_TRANSFORM_CONDITIONALS: bool
 
-    # : (?action_view_helpers: bool, ?analyze: bool, ?arena_stats: bool, ?dot_notation_tags: bool, ?erb_openers: Array[String], ?herb_directives: bool, ?html: bool, ?iteration_nodes: bool, ?max_errors: Integer?, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?render_nodes: bool, ?strict: bool, ?strict_locals: bool, ?timeout: Numeric, ?track_locations: bool, ?track_whitespace: bool, ?transform_conditionals: bool) -> void
-    def initialize: (?action_view_helpers: bool, ?analyze: bool, ?arena_stats: bool, ?dot_notation_tags: bool, ?erb_openers: Array[String], ?herb_directives: bool, ?html: bool, ?iteration_nodes: bool, ?max_errors: Integer?, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?render_nodes: bool, ?strict: bool, ?strict_locals: bool, ?timeout: Numeric, ?track_locations: bool, ?track_whitespace: bool, ?transform_conditionals: bool) -> void
+    # : (?action_view_helpers: bool, ?analyze: bool, ?arena_stats: bool, ?dot_notation_tags: bool, ?erb_openers: Array[String], ?herb_directives: bool, ?html: bool, ?iteration_nodes: bool, ?max_errors: Integer?, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?render_nodes: bool, ?ruby_version: String?, ?strict: bool, ?strict_locals: bool, ?timeout: Numeric, ?track_locations: bool, ?track_whitespace: bool, ?transform_conditionals: bool) -> void
+    def initialize: (?action_view_helpers: bool, ?analyze: bool, ?arena_stats: bool, ?dot_notation_tags: bool, ?erb_openers: Array[String], ?herb_directives: bool, ?html: bool, ?iteration_nodes: bool, ?max_errors: Integer?, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?render_nodes: bool, ?ruby_version: String?, ?strict: bool, ?strict_locals: bool, ?timeout: Numeric, ?track_locations: bool, ?track_whitespace: bool, ?transform_conditionals: bool) -> void
 
-    # : () -> Hash[Symbol, (bool | Numeric | Array[String] | nil)]
-    def to_h: () -> Hash[Symbol, bool | Numeric | Array[String] | nil]
+    # : () -> Hash[Symbol, (bool | Numeric | String | Array[String] | nil)]
+    def to_h: () -> Hash[Symbol, bool | Numeric | String | Array[String] | nil]
 
     # : () -> String
     def inspect: () -> String

data/sig/herb.rbs

@@ -1,8 +1,8 @@
 # Generated from lib/herb.rb with RBS::Inline
 
 module Herb
-  # : (String input, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?dot_notation_tags: bool, ?render_nodes: bool, ?strict_locals: bool, ?herb_directives: bool, ?iteration_nodes: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?html: bool, ?erb_openers: Array[String], ?arena_stats: bool) -> ParseResult
-  def self.parse: (String input, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?dot_notation_tags: bool, ?render_nodes: bool, ?strict_locals: bool, ?herb_directives: bool, ?iteration_nodes: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?html: bool, ?erb_openers: Array[String], ?arena_stats: bool) -> ParseResult
+  # : (String input, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?dot_notation_tags: bool, ?render_nodes: bool, ?strict_locals: bool, ?herb_directives: bool, ?iteration_nodes: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?html: bool, ?erb_openers: Array[String], ?ruby_version: String?, ?arena_stats: bool) -> ParseResult
+  def self.parse: (String input, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?dot_notation_tags: bool, ?render_nodes: bool, ?strict_locals: bool, ?herb_directives: bool, ?iteration_nodes: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?html: bool, ?erb_openers: Array[String], ?ruby_version: String?, ?arena_stats: bool) -> ParseResult
 
   # : (String input, ?erb_openers: Array[String], ?arena_stats: bool) -> LexResult
   def self.lex: (String input, ?erb_openers: Array[String], ?arena_stats: bool) -> LexResult

data/src/analyze/action_view/attribute_extraction_helpers.c

@@ -4,10 +4,12 @@
 #include "../../include/lib/hb_array.h"
 #include "../../include/lib/hb_buffer.h"
 #include "../../include/lib/hb_string.h"
+#include "../../include/prism/prism_helpers.h"
 #include "../../include/util/html_util.h"
 #include "../../include/util/util.h"
 
 #include <prism.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -39,14 +41,14 @@ static void compute_position_pair(
   position_T* out_end
 ) {
   *out_start = prism_location_to_position_with_offset(location, original_source, erb_content_offset, source);
-  pm_location_t end_location = { .start = location->end, .end = location->end };
+  pm_location_t end_location = { .start = herb_prism_location_end(*location), .length = 0 };
   *out_end = prism_location_to_position_with_offset(&end_location, original_source, erb_content_offset, source);
 }
 
 static void extract_key_name_location(pm_node_t* key, pm_location_t* out_name_loc) {
   if (key->type == PM_SYMBOL_NODE) {
     pm_symbol_node_t* symbol = (pm_symbol_node_t*) key;
-    *out_name_loc = symbol->value_loc;
+    *out_name_loc = symbol->content_loc;
   } else if (key->type == PM_STRING_NODE) {
     pm_string_node_t* string_node = (pm_string_node_t*) key;
     *out_name_loc = string_node->content_loc;
@@ -69,7 +71,7 @@ static void compute_separator_info(
   *out_separator_end =
     prism_location_to_position_with_offset(&assoc->value->location, original_source, erb_content_offset, source);
 
-  if (assoc->operator_loc.start != NULL) {
+  if (herb_prism_location_assigned(assoc->operator_loc)) {
     *out_separator_string = " => ";
     *out_separator_type = TOKEN_EQUALS;
     *out_separator_start = key_end;
@@ -78,8 +80,8 @@ static void compute_separator_info(
     *out_separator_type = TOKEN_COLON;
 
     pm_location_t colon_loc = {
-      .start = assoc->key->location.end - 1,
-      .end = assoc->key->location.end - 1,
+      .start = herb_prism_location_end(assoc->key->location) - 1,
+      .length = 0,
     };
 
     *out_separator_start =
@@ -102,7 +104,7 @@ static void extract_delimited_locations(
     pm_symbol_node_t* symbol_node = (pm_symbol_node_t*) node;
     *out_opening = &symbol_node->opening_loc;
     *out_closing = &symbol_node->closing_loc;
-    *out_content = &symbol_node->value_loc;
+    *out_content = &symbol_node->content_loc;
   } else {
     *out_opening = NULL;
     *out_closing = NULL;
@@ -127,7 +129,8 @@ static void compute_value_positions(
 
   extract_delimited_locations(value_node, &opening_loc, &closing_loc, &content_loc);
 
-  if (opening_loc && opening_loc->start != NULL && closing_loc && closing_loc->start != NULL) {
+  if (opening_loc && herb_prism_location_assigned(*opening_loc) && closing_loc
+      && herb_prism_location_assigned(*closing_loc)) {
     compute_position_pair(
       &*opening_loc,
       source,
@@ -167,7 +170,7 @@ static void fill_attribute_positions(
   );
 
   position_T key_end;
-  pm_location_t key_end_loc = { .start = assoc->key->location.end, .end = assoc->key->location.end };
+  pm_location_t key_end_loc = { .start = herb_prism_location_end(assoc->key->location), .length = 0 };
   key_end = prism_location_to_position_with_offset(&key_end_loc, original_source, erb_content_offset, source);
 
   compute_separator_info(
@@ -246,6 +249,7 @@ static char* join_static_string_array(pm_array_node_t* array, hb_allocator_T* al
 static AST_NODE_T* create_attribute_from_value(
   const char* name_string,
   pm_node_t* value_node,
+  const uint8_t* source,
   attribute_positions_T* positions,
   hb_allocator_T* allocator,
   bool is_nested
@@ -281,8 +285,8 @@ static AST_NODE_T* create_attribute_from_value(
 
     return (AST_NODE_T*) create_html_attribute_node_precise(name_string, "false", positions, allocator);
   } else if (value_node->type == PM_INTEGER_NODE) {
-    size_t value_length = value_node->location.end - value_node->location.start;
-    char* value_string = hb_allocator_strndup(allocator, (const char*) value_node->location.start, value_length);
+    char* value_string =
+      hb_allocator_strndup(allocator, (const char*) (source + value_node->location.start), value_node->location.length);
     if (!value_string) { return NULL; }
 
     AST_HTML_ATTRIBUTE_NODE_T* attribute =
@@ -294,15 +298,17 @@ static AST_NODE_T* create_attribute_from_value(
     return (AST_NODE_T*) create_html_attribute_with_interpolated_value(
       name_string,
       (pm_interpolated_string_node_t*) value_node,
+      source,
       positions->name_start,
       positions->value_end,
       allocator
     );
   } else {
-    size_t value_length = value_node->location.end - value_node->location.start;
-    char* raw_content = hb_allocator_strndup(allocator, (const char*) value_node->location.start, value_length);
+    size_t value_length = value_node->location.length;
+    char* raw_content =
+      hb_allocator_strndup(allocator, (const char*) (source + value_node->location.start), value_length);
 
-    if (raw_content && value_node->location.start) {
+    if (raw_content && herb_prism_location_assigned(value_node->location)) {
       char* ruby_content = raw_content;
       hb_buffer_T wrapper;
       bool wrapped = false;
@@ -488,8 +494,14 @@ AST_NODE_T* extract_html_attribute_from_assoc(
   fill_attribute_positions(assoc, source, original_source, erb_content_offset, &positions);
 
   char* dashed_name = convert_underscores_to_dashes(name_string);
-  AST_NODE_T* attribute_node =
-    create_attribute_from_value(dashed_name ? dashed_name : name_string, assoc->value, &positions, allocator, false);
+  AST_NODE_T* attribute_node = create_attribute_from_value(
+    dashed_name ? dashed_name : name_string,
+    assoc->value,
+    source,
+    &positions,
+    allocator,
+    false
+  );
 
   if (dashed_name) { free(dashed_name); }
   hb_allocator_dealloc(allocator, name_string);
@@ -516,8 +528,9 @@ hb_array_T* extract_html_attributes_from_keyword_hash(
       pm_assoc_splat_node_t* splat = (pm_assoc_splat_node_t*) element;
 
       if (splat->value) {
-        size_t value_length = splat->value->location.end - splat->value->location.start;
-        char* value_source = hb_allocator_strndup(allocator, (const char*) splat->value->location.start, value_length);
+        size_t value_length = splat->value->location.length;
+        char* value_source =
+          hb_allocator_strndup(allocator, (const char*) (source + splat->value->location.start), value_length);
 
         if (value_source) {
           hb_buffer_T wrapped;
@@ -560,9 +573,9 @@ hb_array_T* extract_html_attributes_from_keyword_hash(
             pm_assoc_splat_node_t* splat = (pm_assoc_splat_node_t*) hash_element;
 
             if (splat->value) {
-              size_t value_length = splat->value->location.end - splat->value->location.start;
+              size_t value_length = splat->value->location.length;
               char* value_source =
-                hb_allocator_strndup(allocator, (const char*) splat->value->location.start, value_length);
+                hb_allocator_strndup(allocator, (const char*) (source + splat->value->location.start), value_length);
 
               if (value_source) {
                 hb_buffer_T wrapped;
@@ -612,8 +625,14 @@ hb_array_T* extract_html_attributes_from_keyword_hash(
             attribute_positions_T hash_positions;
             fill_attribute_positions(hash_assoc, source, original_source, erb_content_offset, &hash_positions);
 
-            AST_NODE_T* attribute =
-              create_attribute_from_value(attribute_key_string, hash_assoc->value, &hash_positions, allocator, true);
+            AST_NODE_T* attribute = create_attribute_from_value(
+              attribute_key_string,
+              hash_assoc->value,
+              source,
+              &hash_positions,
+              allocator,
+              true
+            );
 
             if (attribute) { hb_array_append(attributes, attribute); }
             hb_allocator_dealloc(allocator, attribute_key_string);

data/src/analyze/action_view/generated_handlers.c

@@ -16,41 +16,41 @@
 bool detect_image_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 9 && strncmp((const char*) constant->start, "image_tag", 9) == 0;
+  return constant && pm_constant_length(constant) == 9 && strncmp((const char*) pm_constant_start(constant), "image_tag", 9) == 0;
 }
 
 bool detect_javascript_include_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 22 && strncmp((const char*) constant->start, "javascript_include_tag", 22) == 0;
+  return constant && pm_constant_length(constant) == 22 && strncmp((const char*) pm_constant_start(constant), "javascript_include_tag", 22) == 0;
 }
 
 bool detect_stylesheet_link_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 19 && strncmp((const char*) constant->start, "stylesheet_link_tag", 19) == 0;
+  return constant && pm_constant_length(constant) == 19 && strncmp((const char*) pm_constant_start(constant), "stylesheet_link_tag", 19) == 0;
 }
 
 bool detect_javascript_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 14 && strncmp((const char*) constant->start, "javascript_tag", 14) == 0;
+  return constant && pm_constant_length(constant) == 14 && strncmp((const char*) pm_constant_start(constant), "javascript_tag", 14) == 0;
 }
 
 bool detect_content_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 11 && strncmp((const char*) constant->start, "content_tag", 11) == 0;
+  return constant && pm_constant_length(constant) == 11 && strncmp((const char*) pm_constant_start(constant), "content_tag", 11) == 0;
 }
 
 bool detect_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
@@ -60,17 +60,17 @@ bool detect_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
   pm_call_node_t* receiver_node = (pm_call_node_t*) call_node->receiver;
   if (!receiver_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, receiver_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, receiver_node->name);
 
-  return constant && constant->length == 3 && strncmp((const char*) constant->start, "tag", 3) == 0;
+  return constant && pm_constant_length(constant) == 3 && strncmp((const char*) pm_constant_start(constant), "tag", 3) == 0;
 }
 
 bool detect_turbo_frame_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 15 && strncmp((const char*) constant->start, "turbo_frame_tag", 15) == 0;
+  return constant && pm_constant_length(constant) == 15 && strncmp((const char*) pm_constant_start(constant), "turbo_frame_tag", 15) == 0;
 }
 
 // ==========================================================================
@@ -133,14 +133,17 @@ extern bool is_ruby_introspection_method(hb_string_T method_name);
 static char* extract_tag_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->name) { return NULL; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
   if (!constant) { return NULL; }
 
-  if (is_ruby_introspection_method(hb_string_from_data((const char*) constant->start, constant->length))) { return NULL; }
+  const char* constant_start = (const char*) pm_constant_start(constant);
+  size_t constant_length = pm_constant_length(constant);
 
-  char* name = hb_allocator_strndup(allocator, (const char*) constant->start, constant->length);
+  if (is_ruby_introspection_method(hb_string_from_data(constant_start, constant_length))) { return NULL; }
 
-  for (size_t i = 0; i < constant->length && name[i] != '\0'; i++) {
+  char* name = hb_allocator_strndup(allocator, constant_start, constant_length);
+
+  for (size_t i = 0; i < constant_length && name[i] != '\0'; i++) {
     if (name[i] == '_') { name[i] = '-'; }
   }
 
@@ -182,9 +185,7 @@ static char* extract_stylesheet_link_tag_content(pm_call_node_t* _call_node, pm_
   return NULL;
 }
 
-static char* extract_javascript_tag_content(pm_call_node_t* call_node, pm_parser_t* _parser, hb_allocator_T* allocator) {
-  (void) _parser;
-
+static char* extract_javascript_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->arguments) { return NULL; }
 
   pm_arguments_node_t* arguments = call_node->arguments;
@@ -200,17 +201,16 @@ static char* extract_javascript_tag_content(pm_call_node_t* call_node, pm_parser
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = first_argument->location.end - first_argument->location.start;
-  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+  const uint8_t* source = pm_parser_start(parser);
+  size_t source_length = first_argument->location.length;
+  return hb_allocator_strndup(allocator, (const char*) (source + first_argument->location.start), source_length);
 }
 
-static char* extract_content_tag_content(pm_call_node_t* call_node, pm_parser_t* _parser, hb_allocator_T* allocator) {
-  (void) _parser;
-
+static char* extract_content_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node) { return NULL; }
 
 
-  char* block_content = extract_inline_block_content(call_node, allocator);
+  char* block_content = extract_inline_block_content(call_node, parser, allocator);
   if (block_content) { return block_content; }
 
 
@@ -228,10 +228,11 @@ static char* extract_content_tag_content(pm_call_node_t* call_node, pm_parser_t*
           return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
         }
 
-        size_t source_length = argument->location.end - argument->location.start;
+        const uint8_t* source = pm_parser_start(parser);
+        size_t source_length = argument->location.length;
 
 
-        return hb_allocator_strndup(allocator, (const char*) argument->location.start, source_length);
+        return hb_allocator_strndup(allocator, (const char*) (source + argument->location.start), source_length);
 
       }
     }
@@ -241,19 +242,17 @@ static char* extract_content_tag_content(pm_call_node_t* call_node, pm_parser_t*
 }
 
 static char* extract_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) parser;
-
   if (!call_node) { return NULL; }
 
   if (call_node->name) {
-    pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+    const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-    if (constant && is_ruby_introspection_method(hb_string_from_data((const char*) constant->start, constant->length))) {
+    if (constant && is_ruby_introspection_method(hb_string_from_data((const char*) pm_constant_start(constant), pm_constant_length(constant)))) {
       return NULL;
     }
   }
 
-  char* block_content = extract_inline_block_content(call_node, allocator);
+  char* block_content = extract_inline_block_content(call_node, parser, allocator);
   if (block_content) { return block_content; }
 
 
@@ -271,10 +270,11 @@ static char* extract_tag_content(pm_call_node_t* call_node, pm_parser_t* parser,
           return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
         }
 
-        size_t source_length = argument->location.end - argument->location.start;
+        const uint8_t* source = pm_parser_start(parser);
+        size_t source_length = argument->location.length;
 
 
-        return hb_allocator_strndup(allocator, (const char*) argument->location.start, source_length);
+        return hb_allocator_strndup(allocator, (const char*) (source + argument->location.start), source_length);
 
       }
     }

data/src/analyze/action_view/image_tag.c

@@ -5,7 +5,7 @@
 #include <stdbool.h>
 #include <string.h>
 
-char* extract_image_tag_src(pm_call_node_t* call_node, pm_parser_t* _parser, hb_allocator_T* allocator) {
+char* extract_image_tag_src(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->arguments) { return NULL; }
 
   pm_arguments_node_t* arguments = call_node->arguments;
@@ -20,9 +20,13 @@ char* extract_image_tag_src(pm_call_node_t* call_node, pm_parser_t* _parser, hb_
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = first_argument->location.end - first_argument->location.start;
+  const uint8_t* source = pm_parser_start(parser);
 
-  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+  return hb_allocator_strndup(
+    allocator,
+    (const char*) (source + first_argument->location.start),
+    first_argument->location.length
+  );
 }
 
 bool image_tag_source_is_url(const char* source, size_t length) {

data/src/analyze/action_view/javascript_include_tag.c

@@ -6,7 +6,6 @@
 #include <string.h>
 
 char* extract_javascript_include_tag_src(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) parser;
 
   if (!call_node || !call_node->arguments) { return NULL; }
 
@@ -22,8 +21,12 @@ char* extract_javascript_include_tag_src(pm_call_node_t* call_node, pm_parser_t*
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = first_argument->location.end - first_argument->location.start;
-  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+  const uint8_t* source = pm_parser_start(parser);
+  return hb_allocator_strndup(
+    allocator,
+    (const char*) (source + first_argument->location.start),
+    first_argument->location.length
+  );
 }
 
 bool javascript_include_tag_source_is_url(const char* source, size_t length) {

data/src/analyze/action_view/link_to.c

@@ -25,9 +25,10 @@ char* wrap_in_url_for(const char* source, size_t source_length, hb_allocator_T*
 bool detect_link_to(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 7 && strncmp((const char*) constant->start, "link_to", 7) == 0;
+  return constant && pm_constant_length(constant) == 7
+      && strncmp((const char*) pm_constant_start(constant), "link_to", 7) == 0;
 }
 
 bool is_route_helper_node(pm_node_t* node, pm_parser_t* parser) {
@@ -36,11 +37,11 @@ bool is_route_helper_node(pm_node_t* node, pm_parser_t* parser) {
   pm_call_node_t* call = (pm_call_node_t*) node;
   if (!call->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call->name);
-  if (!constant || constant->length < 5) { return false; }
+  const pm_constant_t* constant = pm_parser_constant(parser, call->name);
+  if (!constant || pm_constant_length(constant) < 5) { return false; }
 
-  const char* name = (const char*) constant->start;
-  size_t length = constant->length;
+  const char* name = (const char*) pm_constant_start(constant);
+  size_t length = pm_constant_length(constant);
 
   return (length >= 5 && strncmp(name + length - 5, "_path", 5) == 0)
       || (length >= 4 && strncmp(name + length - 4, "_url", 4) == 0);
@@ -54,11 +55,9 @@ char* extract_link_to_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, h
 }
 
 char* extract_link_to_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) parser;
-
   if (!call_node) { return NULL; }
 
-  char* block_content = extract_inline_block_content(call_node, allocator);
+  char* block_content = extract_inline_block_content(call_node, parser, allocator);
   if (block_content) { return block_content; }
 
   if (!call_node->arguments) { return NULL; }
@@ -76,7 +75,8 @@ char* extract_link_to_content(pm_call_node_t* call_node, pm_parser_t* parser, hb
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = first_argument->location.end - first_argument->location.start;
+  const uint8_t* source = pm_parser_start(parser);
+  size_t source_length = first_argument->location.length;
 
   // Format: "<expression>.to_s"
   if (arguments->arguments.size == 1) {
@@ -85,21 +85,21 @@ char* extract_link_to_content(pm_call_node_t* call_node, pm_parser_t* parser, hb
     size_t total_length = source_length + suffix_len;
     char* ruby_expression = hb_allocator_alloc(allocator, total_length + 1);
 
-    memcpy(ruby_expression, (const char*) first_argument->location.start, source_length);
+    memcpy(ruby_expression, (const char*) (source + first_argument->location.start), source_length);
     memcpy(ruby_expression + source_length, suffix, suffix_len);
     ruby_expression[total_length] = '\0';
 
     return ruby_expression;
   }
 
-  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+  return hb_allocator_strndup(allocator, (const char*) (source + first_argument->location.start), source_length);
 }
 
 char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) parser;
-
   if (!call_node || !call_node->arguments) { return NULL; }
 
+  const uint8_t* source = pm_parser_start(parser);
+
   pm_arguments_node_t* arguments = call_node->arguments;
   bool has_inline_block = call_node->block && call_node->block->type == PM_BLOCK_NODE;
 
@@ -112,13 +112,13 @@ char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
       return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
     }
 
-    size_t source_length = first_argument->location.end - first_argument->location.start;
+    size_t source_length = first_argument->location.length;
 
     if (is_route_helper_node(first_argument, parser)) {
-      return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+      return hb_allocator_strndup(allocator, (const char*) (source + first_argument->location.start), source_length);
     }
 
-    return wrap_in_url_for((const char*) first_argument->location.start, source_length, allocator);
+    return wrap_in_url_for((const char*) (source + first_argument->location.start), source_length, allocator);
   }
 
   // Format: "url_for(<expression>)"
@@ -127,13 +127,13 @@ char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
 
     if (first_argument->type == PM_STRING_NODE || first_argument->type == PM_NIL_NODE) { return NULL; }
 
-    size_t source_length = first_argument->location.end - first_argument->location.start;
+    size_t source_length = first_argument->location.length;
 
     if (is_route_helper_node(first_argument, parser)) {
-      return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+      return hb_allocator_strndup(allocator, (const char*) (source + first_argument->location.start), source_length);
     }
 
-    return wrap_in_url_for((const char*) first_argument->location.start, source_length, allocator);
+    return wrap_in_url_for((const char*) (source + first_argument->location.start), source_length, allocator);
   }
 
   if (arguments->arguments.size < 2) { return NULL; }
@@ -146,13 +146,13 @@ char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = second_argument->location.end - second_argument->location.start;
+  size_t source_length = second_argument->location.length;
 
   if (!is_route_helper_node(second_argument, parser)) {
-    return wrap_in_url_for((const char*) second_argument->location.start, source_length, allocator);
+    return wrap_in_url_for((const char*) (source + second_argument->location.start), source_length, allocator);
   }
 
-  return hb_allocator_strndup(allocator, (const char*) second_argument->location.start, source_length);
+  return hb_allocator_strndup(allocator, (const char*) (source + second_argument->location.start), source_length);
 }
 
 bool link_to_supports_block(void) {

data/src/analyze/action_view/registry.c

@@ -59,7 +59,7 @@ size_t get_tag_helper_handlers_count(void) {
   return handlers_count;
 }
 
-char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator) {
+char* extract_inline_block_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->block || call_node->block->type != PM_BLOCK_NODE) { return NULL; }
 
   pm_block_node_t* block_node = (pm_block_node_t*) call_node->block;
@@ -78,6 +78,10 @@ char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* al
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = statement->location.end - statement->location.start;
-  return hb_allocator_strndup(allocator, (const char*) statement->location.start, source_length);
+  const uint8_t* source = pm_parser_start(parser);
+  return hb_allocator_strndup(
+    allocator,
+    (const char*) (source + statement->location.start),
+    statement->location.length
+  );
 }

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -304,6 +304,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
   pm_interpolated_string_node_t* interpolated_node,
+  const uint8_t* source,
   position_T start_position,
   position_T end_position,
   hb_allocator_T* allocator
@@ -338,19 +339,10 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
       }
     } else if (part->type == PM_EMBEDDED_STATEMENTS_NODE) {
       pm_embedded_statements_node_t* embedded = (pm_embedded_statements_node_t*) part;
-      const uint8_t* content_start;
-      const uint8_t* content_end;
-
-      if (embedded->statements) {
-        content_start = embedded->statements->base.location.start;
-        content_end = embedded->statements->base.location.end;
-      } else {
-        content_start = part->location.start;
-        content_end = part->location.end;
-      }
+      pm_location_t content_location = embedded->statements ? embedded->statements->base.location : part->location;
 
-      size_t ruby_length = content_end - content_start;
-      char* ruby_content = hb_allocator_strndup(allocator, (const char*) content_start, ruby_length);
+      char* ruby_content =
+        hb_allocator_strndup(allocator, (const char*) (source + content_location.start), content_location.length);
 
       if (ruby_content) {
         AST_RUBY_LITERAL_NODE_T* ruby_node = ast_ruby_literal_node_init(
@@ -386,6 +378,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
 AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
   const char* name_string,
   pm_interpolated_string_node_t* interpolated_node,
+  const uint8_t* source,
   position_T start_position,
   position_T end_position,
   hb_allocator_T* allocator
@@ -396,7 +389,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
     create_attribute_name_node(name_string, start_position, end_position, allocator);
 
   AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node =
-    create_interpolated_attribute_value(interpolated_node, start_position, end_position, allocator);
+    create_interpolated_attribute_value(interpolated_node, source, start_position, end_position, allocator);
 
   token_T* equals_token = create_synthetic_token(allocator, "=", TOKEN_EQUALS, start_position, end_position);