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

data/sig/herb/engine/slots/dynamics_compiler.rbs

@@ -65,7 +65,8 @@ module Herb
       # An item is keyed by the key its template declares, through `herb-key` or `id` or a
       # `<%# herb:key %>` directive, which is what makes it survive being reordered. `Visitor`
       # decides what that key is and this evaluates it, so an item arrives under the same key the
-      # marker around it carries. A collection that declares none falls back to position.
+      # marker around it carries. A collection that declares none falls back to position, counting
+      # from the first iteration, so a change re-renders every row from the first one that differs.
       #
       # ## A partial keeps its own values
       #
@@ -88,7 +89,7 @@ module Herb
       #
       # ## Blocks
       #
-      # A tag that takes a block, such as `<%= form_with do |f| %>`, owns an entry holding everything
+      # A tag that takes a block, such as `<%= form_with do |f| %>`, owns an entry holding the markup
       # the block rendered, because the helper wraps that output in markup of its own that only the
       # helper can produce. What the template wrote inside the block keeps its own indices alongside:
       #
@@ -99,6 +100,20 @@ module Herb
       # and the whole block. Slot 1 is inside slot 0, which the client already has to reason about
       # for conditionals and collections.
       #
+      # A partial inside a block is the exception to that fallback. It keeps its own values on its slot,
+      # and the block's entry is a String that cannot hold them, so the entry leaves the partial's
+      # markup out:
+      #
+      #     <%= form_with(model: @user) do |f| %><%= render "card" %><% end %>
+      #     #=> { 0 => "<form></form>", 1 => { template: "app/views/_card.html.erb", ... } }
+      #
+      # That entry cannot stand in for the block, so it must not be written over a block holding a
+      # partial. The client never writes a block's entry while the page marks slots inside that block.
+      # It reports the block as deferred instead, even when nothing in the block changed.
+      #
+      # A render that comes back as markup, because its template is not compiled for slots, is written
+      # into the entry as usual, and the entry stays whole.
+      #
       # A block yielding more than once is the exception, since one index cannot stand for the several
       # values its interior took. `each` and the other iterations are compiled as collections for that
       # reason, and a helper that yields repeatedly reports the last value its interior took.
@@ -117,6 +132,8 @@ module Herb
 
         OCCURRENCE_BUFFER: String
 
+        RENDERED_BUFFER: String
+
         BRANCHING_NODES: Array[String]
 
         class Compiler < Herb::Engine::Compiler
@@ -132,6 +149,9 @@ module Herb
           # : (untyped) -> void
           def visit_erb_content_node: (untyped) -> void
 
+          # : (untyped) -> void
+          def visit_ruby_literal_node: (untyped) -> void
+
           # : (untyped) -> void
           def visit_erb_yield_node: (untyped) -> void
 
@@ -246,8 +266,8 @@ module Herb
         # : (Integer) -> bool
         def boolean_presence?: (Integer) -> bool
 
-        # : (String, Integer?, bool) -> void
-        def add_dynamic_block: (String, Integer?, bool) -> void
+        # : (String, Integer?, bool, ?rendering: bool) -> void
+        def add_dynamic_block: (String, Integer?, bool, ?rendering: bool) -> void
 
         # : (String, ?escaped: bool) -> void
         def add_expression_block_end: (String, ?escaped: bool) -> void
@@ -302,9 +322,6 @@ module Herb
         # : (Integer) -> void
         def scope_item_end: (Integer) -> void
 
-        # : (Integer) -> bool
-        def keyed?: (Integer) -> bool
-
         # : (Integer) -> String
         def item_seeds: (Integer) -> String
 
@@ -329,6 +346,9 @@ module Herb
         # : (Integer) -> bool
         def interpolated?: (Integer) -> bool
 
+        # : (String) -> void
+        def add_block_render: (String) -> void
+
         # : (String) -> void
         def add_block_dynamic: (String) -> void
 

data/sig/herb/engine/slots/markers.rbs

@@ -14,15 +14,29 @@ module Herb
 
         COMMENT: Regexp
 
+        FOREIGN_ATTRIBUTE: String
+
+        FOREIGN_ROOTS: Hash[Symbol, String]
+
+        SVG_INTEGRATION_POINTS: Array[String]
+
+        MATH_INTEGRATION_POINTS: Array[String]
+
         # : (String) -> bool
         def self.marker?: (String) -> bool
 
         # : (String) -> String
         def self.seeds_expression: (String) -> String
 
+        # : (Symbol, String) -> Symbol
+        def self.namespace_within: (Symbol, String) -> Symbol
+
         # : (Integer, Symbol) -> String
         def slot_open: (Integer, Symbol) -> String
 
+        # : (String, Symbol) -> String
+        def foreign: (String, Symbol) -> String
+
         # : (Array[[Integer, Symbol, String?]]) -> String
         def element_anchors: (Array[[ Integer, Symbol, String? ]]) -> String
 

data/sig/herb/engine/slots/visitor.rbs

@@ -57,6 +57,8 @@ module Herb
 
         OCCURRENCE: String
 
+        POSITION: String
+
         NAME_ATTRIBUTE: String
 
         KEY_ATTRIBUTE: String
@@ -121,6 +123,15 @@ module Herb
 
           # : () -> bool
           def interpolated?: () -> bool
+
+          # : () -> bool
+          def positional?: () -> bool
+
+          # : () -> String
+          def position_variable: () -> String
+
+          # : () -> String?
+          def item_key: () -> String?
         end
 
         # : (String) -> bool
@@ -404,6 +415,9 @@ module Herb
 
         def erb_output_node: (untyped code) -> untyped
 
+        # : (Array[untyped], Integer) -> String
+        def attribute_spacing: (Array[untyped], Integer) -> String
+
         private
 
         def visit_children_with_paths: (untyped children) -> untyped
@@ -526,16 +540,17 @@ module Herb
         # : (untyped) -> String?
         def attribute_expression_for: (untyped) -> String?
 
-        def insert_markers: (untyped node) -> untyped
+        # : (untyped, ?Symbol) -> untyped
+        def insert_markers: (untyped, ?Symbol) -> untyped
 
         # : (untyped) -> Integer?
         def content_anchor_index: (untyped) -> Integer?
 
-        # : (untyped, Integer?) -> void
-        def mark_branches: (untyped, Integer?) -> void
+        # : (untyped, Integer?, ?Symbol) -> void
+        def mark_branches: (untyped, Integer?, ?Symbol) -> void
 
-        # : (String, Array[untyped]) -> void
-        def park_branch: (String, Array[untyped]) -> void
+        # : (String, String, Array[untyped], Symbol) -> void
+        def park_branch: (String, String, Array[untyped], Symbol) -> void
 
         # : (Herb::AST::DocumentNode) -> void
         def append_statics: (Herb::AST::DocumentNode) -> void
@@ -558,25 +573,28 @@ module Herb
         # : (untyped) -> Array[Array[Herb::AST::Node]]
         def branch_bodies: (untyped) -> Array[Array[Herb::AST::Node]]
 
-        # : (Herb::AST::Node, Integer?) -> void
-        def wrap_items: (Herb::AST::Node, Integer?) -> void
+        # : (Array[untyped], Integer, Integer?) -> Integer
+        def insert_position_counter: (Array[untyped], Integer, Integer?) -> Integer
+
+        # : (Herb::AST::Node, Integer?, ?Symbol) -> void
+        def wrap_items: (Herb::AST::Node, Integer?, ?Symbol) -> void
 
         # : (untyped) -> Array[String]?
         def attribute_segments: (untyped) -> Array[String]?
 
-        # : (Integer, untyped) -> void
-        def park_keyed: (Integer, untyped) -> void
+        # : (Integer, untyped, Symbol) -> void
+        def park_keyed: (Integer, untyped, Symbol) -> void
 
-        # : (untyped, untyped) -> Array[untyped]?
-        def park_item: (untyped, untyped) -> Array[untyped]?
+        # : (untyped, untyped, Symbol) -> Array[untyped]?
+        def park_item: (untyped, untyped, Symbol) -> Array[untyped]?
 
         def anchor_attributes: (untyped node, ?untyped content_index) -> untyped
 
         # : (Slot) -> String?
         def anchor_name_for: (Slot) -> String?
 
-        # : (Herb::AST::Node) { (Array[untyped]) -> void } -> void
-        def each_child_array: (Herb::AST::Node) { (Array[untyped]) -> void } -> void
+        # : (Herb::AST::Node, ?Symbol) { (Array[untyped]) -> void } -> void
+        def each_child_array: (Herb::AST::Node, ?Symbol) { (Array[untyped]) -> void } -> void
 
         # : (Herb::AST::DocumentNode) -> void
         def wrap_region: (Herb::AST::DocumentNode) -> void

data/sig/herb/engine/visitors/instrumentation_visitor.rbs

@@ -72,6 +72,8 @@ module Herb
       # : (Herb::AST::Node, Herb::AST::Node) -> Herb::AST::Node
       def replacing: (Herb::AST::Node, Herb::AST::Node) -> Herb::AST::Node
 
+      def literal?: (untyped node) -> untyped
+
       def framed?: (untyped node) -> untyped
 
       def assignment?: (untyped node) -> untyped
@@ -105,7 +107,9 @@ module Herb
 
       def code: (untyped node) -> untyped
 
-      def erb_node: (untyped node, untyped opening, untyped code) -> untyped
+      def rewrapped: (untyped node, untyped code) -> untyped
+
+      def erb_node: (untyped node, untyped opening, untyped code, ?closing: untyped) -> untyped
     end
   end
 end

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/sig/serialized_ast_nodes.rbs

@@ -360,6 +360,7 @@ module Herb
     tag_opening: Herb::Token,
     content: Herb::Token,
     tag_closing: Herb::Token,
+    prism_node: String,
   }
 
   type serialized_erb_in_node = serialized_node & {

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) {