herb 0.9.0-arm-linux-gnu → 0.9.2-arm-linux-gnu

data/sig/herb/errors.rbs

@@ -458,5 +458,119 @@ module Herb
       # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
       def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
     end
+
+    class RenderAmbiguousLocalsError < Error
+      include Colors
+
+      attr_reader partial: String?
+
+      # : (String, Location?, String, String) -> void
+      def initialize: (String, Location?, String, String) -> void
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : () -> serialized_render_ambiguous_locals_error
+      def to_hash: () -> serialized_render_ambiguous_locals_error
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    class RenderMissingLocalsError < Error
+      include Colors
+
+      attr_reader partial: String?
+
+      attr_reader keywords: String?
+
+      # : (String, Location?, String, String, String) -> void
+      def initialize: (String, Location?, String, String, String) -> void
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : () -> serialized_render_missing_locals_error
+      def to_hash: () -> serialized_render_missing_locals_error
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    class RenderNoArgumentsError < Error
+      include Colors
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    class RenderConflictingPartialError < Error
+      include Colors
+
+      attr_reader positional_partial: String?
+
+      attr_reader keyword_partial: String?
+
+      # : (String, Location?, String, String, String) -> void
+      def initialize: (String, Location?, String, String, String) -> void
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : () -> serialized_render_conflicting_partial_error
+      def to_hash: () -> serialized_render_conflicting_partial_error
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    class RenderInvalidAsOptionError < Error
+      include Colors
+
+      attr_reader as_value: String?
+
+      # : (String, Location?, String, String) -> void
+      def initialize: (String, Location?, String, String) -> void
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : () -> serialized_render_invalid_as_option_error
+      def to_hash: () -> serialized_render_invalid_as_option_error
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    class RenderObjectAndCollectionError < Error
+      include Colors
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    class RenderLayoutWithoutBlockError < Error
+      include Colors
+
+      attr_reader layout: String?
+
+      # : (String, Location?, String, String) -> void
+      def initialize: (String, Location?, String, String) -> void
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : () -> serialized_render_layout_without_block_error
+      def to_hash: () -> serialized_render_layout_without_block_error
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
   end
 end

data/sig/herb/parser_options.rbs

@@ -10,6 +10,8 @@ module Herb
 
     attr_reader action_view_helpers: bool
 
+    attr_reader render_nodes: bool
+
     attr_reader prism_program: bool
 
     attr_reader prism_nodes: bool
@@ -24,6 +26,8 @@ module Herb
 
     DEFAULT_ACTION_VIEW_HELPERS: bool
 
+    DEFAULT_RENDER_NODES: bool
+
     DEFAULT_PRISM_PROGRAM: bool
 
     DEFAULT_PRISM_NODES: bool

data/sig/herb/visitor.rbs

@@ -121,6 +121,12 @@ module Herb
     # : (Herb::AST::ERBUnlessNode) -> void
     def visit_erb_unless_node: (Herb::AST::ERBUnlessNode) -> void
 
+    # : (Herb::AST::RubyRenderLocalNode) -> void
+    def visit_ruby_render_local_node: (Herb::AST::RubyRenderLocalNode) -> void
+
+    # : (Herb::AST::ERBRenderNode) -> void
+    def visit_erb_render_node: (Herb::AST::ERBRenderNode) -> void
+
     # : (Herb::AST::ERBYieldNode) -> void
     def visit_erb_yield_node: (Herb::AST::ERBYieldNode) -> void
 

data/sig/rubyvm.rbs

@@ -0,0 +1,5 @@
+class RubyVM
+  class InstructionSequence
+    def self.compile: (String source, ?String? file, ?String? path, ?Integer? line, ?freeze: bool, **untyped options) -> RubyVM::InstructionSequence
+  end
+end

data/sig/serialized_ast_errors.rbs

@@ -112,4 +112,32 @@ module Herb
     nested_tag_column: Integer,
   }
 
+  type serialized_render_ambiguous_locals_error = serialized_error & {
+    partial: String,
+  }
+
+  type serialized_render_missing_locals_error = serialized_error & {
+    partial: String,
+    keywords: String,
+  }
+
+  type serialized_render_no_arguments_error = serialized_error & {
+  }
+
+  type serialized_render_conflicting_partial_error = serialized_error & {
+    positional_partial: String,
+    keyword_partial: String,
+  }
+
+  type serialized_render_invalid_as_option_error = serialized_error & {
+    as_value: String,
+  }
+
+  type serialized_render_object_and_collection_error = serialized_error & {
+  }
+
+  type serialized_render_layout_without_block_error = serialized_error & {
+    layout: String,
+  }
+
 end

data/sig/serialized_ast_nodes.rbs

@@ -268,6 +268,37 @@ module Herb
     end_node: Herb::AST::ERBEndNode,
   }
 
+  type serialized_ruby_render_local_node = serialized_node & {
+    name: Herb::Token,
+    value: Herb::AST::RubyLiteralNode,
+  }
+
+  type serialized_erb_render_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    analyzed_ruby: nil,
+    prism_node: String,
+    partial: Herb::Token,
+    template_path: Herb::Token,
+    layout: Herb::Token,
+    file: Herb::Token,
+    inline_template: Herb::Token,
+    body: Herb::Token,
+    plain: Herb::Token,
+    html: Herb::Token,
+    renderable: Herb::Token,
+    collection: Herb::Token,
+    object: Herb::Token,
+    as_name: Herb::Token,
+    spacer_template: Herb::Token,
+    formats: Herb::Token,
+    variants: Herb::Token,
+    handlers: Herb::Token,
+    content_type: Herb::Token,
+    locals: Array[Herb::AST::RubyRenderLocalNode],
+  }
+
   type serialized_erb_yield_node = serialized_node & {
     tag_opening: Herb::Token,
     content: Herb::Token,

data/src/analyze/action_view/attribute_extraction_helpers.c

@@ -1,5 +1,6 @@
 #include "../../include/analyze/action_view/attribute_extraction_helpers.h"
 #include "../../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../../include/html_util.h"
 #include "../../include/util.h"
 #include "../../include/util/hb_allocator.h"
 #include "../../include/util/hb_array.h"
@@ -58,6 +59,14 @@ static AST_HTML_ATTRIBUTE_NODE_T* create_attribute_from_value(
     hb_allocator_dealloc(allocator, value_string);
 
     return attribute;
+  } else if (value_node->type == PM_TRUE_NODE) {
+    if (is_boolean_attribute(hb_string((char*) name_string))) {
+      return create_html_attribute_node(name_string, NULL, start_position, end_position, allocator);
+    }
+    return create_html_attribute_node(name_string, "true", start_position, end_position, allocator);
+  } else if (value_node->type == PM_FALSE_NODE) {
+    if (is_boolean_attribute(hb_string((char*) name_string))) { return NULL; }
+    return create_html_attribute_node(name_string, "false", start_position, end_position, allocator);
   } else if (value_node->type == PM_INTERPOLATED_STRING_NODE) {
     return create_html_attribute_with_interpolated_value(
       name_string,
@@ -265,7 +274,7 @@ bool has_html_attributes_in_call(pm_call_node_t* call_node) {
 
   pm_node_t* last_argument = arguments->arguments.nodes[arguments->arguments.size - 1];
 
-  return last_argument && last_argument->type == PM_KEYWORD_HASH_NODE;
+  return last_argument && (last_argument->type == PM_KEYWORD_HASH_NODE || last_argument->type == PM_HASH_NODE);
 }
 
 hb_array_T* extract_html_attributes_from_call_node(
@@ -280,6 +289,19 @@ hb_array_T* extract_html_attributes_from_call_node(
   pm_arguments_node_t* arguments = call_node->arguments;
   pm_node_t* last_argument = arguments->arguments.nodes[arguments->arguments.size - 1];
 
+  if (last_argument->type == PM_HASH_NODE) {
+    pm_hash_node_t* hash_node = (pm_hash_node_t*) last_argument;
+    pm_keyword_hash_node_t synthetic = { .base = hash_node->base, .elements = hash_node->elements };
+
+    return extract_html_attributes_from_keyword_hash(
+      &synthetic,
+      source,
+      original_source,
+      erb_content_offset,
+      allocator
+    );
+  }
+
   return extract_html_attributes_from_keyword_hash(
     (pm_keyword_hash_node_t*) last_argument,
     source,

data/src/analyze/action_view/content_tag.c

@@ -38,23 +38,31 @@ char* extract_content_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, h
 char* extract_content_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   (void) parser;
 
-  if (!call_node || !call_node->arguments) { return NULL; }
+  if (!call_node) { return NULL; }
 
-  pm_arguments_node_t* arguments = call_node->arguments;
-  if (arguments->arguments.size < 2) { return NULL; }
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
 
-  pm_node_t* second_argument = arguments->arguments.nodes[1];
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
 
-  if (second_argument->type == PM_KEYWORD_HASH_NODE) { return NULL; }
+    if (arguments->arguments.size >= 2) {
+      pm_node_t* second_argument = arguments->arguments.nodes[1];
 
-  if (second_argument->type == PM_STRING_NODE) {
-    pm_string_node_t* string_node = (pm_string_node_t*) second_argument;
-    size_t length = pm_string_length(&string_node->unescaped);
-    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+      if (second_argument->type != PM_KEYWORD_HASH_NODE) {
+        if (second_argument->type == PM_STRING_NODE) {
+          pm_string_node_t* string_node = (pm_string_node_t*) second_argument;
+          size_t length = pm_string_length(&string_node->unescaped);
+          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;
+        return hb_allocator_strndup(allocator, (const char*) second_argument->location.start, source_length);
+      }
+    }
   }
 
-  size_t source_length = second_argument->location.end - second_argument->location.start;
-  return hb_allocator_strndup(allocator, (const char*) second_argument->location.start, source_length);
+  return NULL;
 }
 
 bool content_tag_supports_block(void) {

data/src/analyze/action_view/javascript_include_tag.c

@@ -0,0 +1,92 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+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);
+  return constant && constant->length == 22
+      && strncmp((const char*) constant->start, "javascript_include_tag", 22) == 0;
+}
+
+char* extract_javascript_include_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) call_node;
+  (void) parser;
+
+  return hb_allocator_strdup(allocator, "script");
+}
+
+char* extract_javascript_include_tag_content(
+  pm_call_node_t* call_node,
+  pm_parser_t* parser,
+  hb_allocator_T* allocator
+) {
+  (void) call_node;
+  (void) parser;
+  (void) allocator;
+
+  return NULL;
+}
+
+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; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  if (!arguments->arguments.size) { return NULL; }
+
+  pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+  if (first_argument->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+    size_t length = pm_string_length(&string_node->unescaped);
+
+    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);
+}
+
+bool javascript_include_tag_source_is_url(const char* source, size_t length) {
+  if (!source || length == 0) { return false; }
+
+  if (length >= 2 && source[0] == '/' && source[1] == '/') { return true; }
+  if (strstr(source, "://") != NULL) { return true; }
+
+  return false;
+}
+
+char* wrap_in_javascript_path(const char* source, size_t source_length, hb_allocator_T* allocator) {
+  const char* prefix = "javascript_path(";
+  const char* suffix = ")";
+  size_t prefix_length = strlen(prefix);
+  size_t suffix_length = strlen(suffix);
+  size_t total_length = prefix_length + source_length + suffix_length;
+  char* result = hb_allocator_alloc(allocator, total_length + 1);
+
+  memcpy(result, prefix, prefix_length);
+  memcpy(result + prefix_length, source, source_length);
+  memcpy(result + prefix_length + source_length, suffix, suffix_length);
+  result[total_length] = '\0';
+
+  return result;
+}
+
+bool javascript_include_tag_supports_block(void) {
+  return false;
+}
+
+const tag_helper_handler_T javascript_include_tag_handler = {
+  .name = "javascript_include_tag",
+  .source = HB_STRING_LITERAL("ActionView::Helpers::AssetTagHelper#javascript_include_tag"),
+  .detect = detect_javascript_include_tag,
+  .extract_tag_name = extract_javascript_include_tag_name,
+  .extract_content = extract_javascript_include_tag_content,
+  .supports_block = javascript_include_tag_supports_block
+};

data/src/analyze/action_view/javascript_tag.c

@@ -0,0 +1,55 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+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);
+  return constant && constant->length == 14 && strncmp((const char*) constant->start, "javascript_tag", 14) == 0;
+}
+
+char* extract_javascript_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) call_node;
+  (void) parser;
+
+  return hb_allocator_strdup(allocator, "script");
+}
+
+char* extract_javascript_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) parser;
+
+  if (!call_node || !call_node->arguments) { return NULL; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  if (!arguments->arguments.size) { return NULL; }
+
+  pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+  if (first_argument->type == PM_KEYWORD_HASH_NODE) { return NULL; }
+
+  if (first_argument->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+    size_t length = pm_string_length(&string_node->unescaped);
+    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);
+}
+
+bool javascript_tag_supports_block(void) {
+  return true;
+}
+
+const tag_helper_handler_T javascript_tag_handler = {
+  .name = "javascript_tag",
+  .source = HB_STRING_LITERAL("ActionView::Helpers::JavaScriptHelper#javascript_tag"),
+  .detect = detect_javascript_tag,
+  .extract_tag_name = extract_javascript_tag_name,
+  .extract_content = extract_javascript_tag_content,
+  .supports_block = javascript_tag_supports_block
+};

data/src/analyze/action_view/link_to.c

@@ -56,7 +56,12 @@ 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 || !call_node->arguments) { return NULL; }
+  if (!call_node) { return NULL; }
+
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
+
+  if (!call_node->arguments) { return NULL; }
 
   pm_arguments_node_t* arguments = call_node->arguments;
   if (!arguments->arguments.size) { return NULL; }
@@ -96,6 +101,25 @@ char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
   if (!call_node || !call_node->arguments) { return NULL; }
 
   pm_arguments_node_t* arguments = call_node->arguments;
+  bool has_inline_block = call_node->block && call_node->block->type == PM_BLOCK_NODE;
+
+  if (has_inline_block && arguments->arguments.size >= 1) {
+    pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+    if (first_argument->type == PM_STRING_NODE) {
+      pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+      size_t length = pm_string_length(&string_node->unescaped);
+      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;
+
+    if (is_route_helper_node(first_argument, parser)) {
+      return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+    }
+
+    return wrap_in_url_for((const char*) first_argument->location.start, source_length, allocator);
+  }
 
   // Format: "url_for(<expression>)"
   if (arguments->arguments.size == 1) {

data/src/analyze/action_view/registry.c

@@ -8,8 +8,10 @@ extern const tag_helper_handler_T content_tag_handler;
 extern const tag_helper_handler_T tag_dot_handler;
 extern const tag_helper_handler_T link_to_handler;
 extern const tag_helper_handler_T turbo_frame_tag_handler;
+extern const tag_helper_handler_T javascript_tag_handler;
+extern const tag_helper_handler_T javascript_include_tag_handler;
 
-static size_t handlers_count = 4;
+static size_t handlers_count = 6;
 
 tag_helper_info_T* tag_helper_info_init(hb_allocator_T* allocator) {
   tag_helper_info_T* info = hb_allocator_alloc(allocator, sizeof(tag_helper_info_T));
@@ -41,7 +43,7 @@ void tag_helper_info_free(tag_helper_info_T** info) {
 }
 
 tag_helper_handler_T* get_tag_helper_handlers(void) {
-  static tag_helper_handler_T static_handlers[4];
+  static tag_helper_handler_T static_handlers[6];
   static bool initialized = false;
 
   if (!initialized) {
@@ -49,6 +51,8 @@ tag_helper_handler_T* get_tag_helper_handlers(void) {
     static_handlers[1] = tag_dot_handler;
     static_handlers[2] = link_to_handler;
     static_handlers[3] = turbo_frame_tag_handler;
+    static_handlers[4] = javascript_tag_handler;
+    static_handlers[5] = javascript_include_tag_handler;
     initialized = true;
   }
 
@@ -58,3 +62,26 @@ tag_helper_handler_T* get_tag_helper_handlers(void) {
 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) {
+  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;
+
+  if (!block_node->body || block_node->body->type != PM_STATEMENTS_NODE) { return NULL; }
+
+  pm_statements_node_t* statements = (pm_statements_node_t*) block_node->body;
+
+  if (statements->body.size != 1) { return NULL; }
+
+  pm_node_t* statement = statements->body.nodes[0];
+
+  if (statement->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) statement;
+    size_t length = pm_string_length(&string_node->unescaped);
+    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);
+}

data/src/analyze/action_view/tag.c

@@ -36,17 +36,23 @@ char* extract_tag_dot_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
 char* extract_tag_dot_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   (void) parser;
 
-  if (!call_node || !call_node->arguments) { return NULL; }
+  if (!call_node) { return NULL; }
 
-  pm_arguments_node_t* arguments = call_node->arguments;
-  if (!arguments->arguments.size) { return NULL; }
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
 
-  pm_node_t* first_argument = arguments->arguments.nodes[0];
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
 
-  if (first_argument->type == PM_STRING_NODE) {
-    pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
-    size_t length = pm_string_length(&string_node->unescaped);
-    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+    if (arguments->arguments.size) {
+      pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+      if (first_argument->type == PM_STRING_NODE) {
+        pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+        size_t length = pm_string_length(&string_node->unescaped);
+        return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+      }
+    }
   }
 
   return NULL;

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -88,7 +88,8 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node(
   AST_HTML_ATTRIBUTE_NAME_NODE_T* name_node =
     create_attribute_name_node(name_string, start_position, end_position, allocator);
 
-  token_T* equals_token = create_synthetic_token(allocator, "=", TOKEN_EQUALS, start_position, end_position);
+  token_T* equals_token =
+    value_string ? create_synthetic_token(allocator, "=", TOKEN_EQUALS, start_position, end_position) : NULL;
   AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node = NULL;
 
   if (value_string) {
@@ -210,8 +211,20 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
         }
       }
     } else if (part->type == PM_EMBEDDED_STATEMENTS_NODE) {
-      size_t ruby_length = part->location.end - part->location.start;
-      char* ruby_content = hb_allocator_strndup(allocator, (const char*) part->location.start, ruby_length);
+      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;
+      }
+
+      size_t ruby_length = content_end - content_start;
+      char* ruby_content = hb_allocator_strndup(allocator, (const char*) content_start, ruby_length);
 
       if (ruby_content) {
         AST_RUBY_LITERAL_NODE_T* ruby_node = ast_ruby_literal_node_init(