herb 0.9.4-arm-linux-gnu → 0.9.5-arm-linux-gnu

data/sig/herb/ast/nodes.rbs

@@ -944,6 +944,7 @@ module Herb
     # |  tag_closing: Herb::Token?,
     # |  prism_node: String?,
     # |  body: Array[Herb::AST::Node],
+    # |  block_arguments: Array[Herb::AST::RubyParameterNode]?,
     # |  rescue_clause: Herb::AST::ERBRescueNode?,
     # |  else_clause: Herb::AST::ERBElseNode?,
     # |  ensure_clause: Herb::AST::ERBEnsureNode?,
@@ -962,6 +963,8 @@ module Herb
 
       attr_reader body: Array[Herb::AST::Node]
 
+      attr_reader block_arguments: Array[Herb::AST::RubyParameterNode]?
+
       attr_reader rescue_clause: Herb::AST::ERBRescueNode?
 
       attr_reader else_clause: Herb::AST::ERBElseNode?
@@ -970,8 +973,8 @@ module Herb
 
       attr_reader end_node: Herb::AST::ERBEndNode?
 
-      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, String, Array[Herb::AST::Node], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
-      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, String, Array[Herb::AST::Node], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, String, Array[Herb::AST::Node], Array[Herb::AST::RubyParameterNode], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, String, Array[Herb::AST::Node], Array[Herb::AST::RubyParameterNode], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
 
       # : () -> Prism::node?
       def deserialized_prism_node: () -> Prism::node?
@@ -1514,12 +1517,7 @@ module Herb
       def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
     end
 
-    # : type serialized_erb_render_node = {
-    # |  tag_opening: Herb::Token?,
-    # |  content: Herb::Token?,
-    # |  tag_closing: Herb::Token?,
-    # |  analyzed_ruby: nil,
-    # |  prism_node: String?,
+    # : type serialized_ruby_render_keywords_node = {
     # |  partial: Herb::Token?,
     # |  template_path: Herb::Token?,
     # |  layout: Herb::Token?,
@@ -1539,19 +1537,9 @@ module Herb
     # |  content_type: Herb::Token?,
     # |  locals: Array[Herb::AST::RubyRenderLocalNode]?,
     # | }
-    class ERBRenderNode < Node
+    class RubyRenderKeywordsNode < Node
       include Colors
 
-      attr_reader tag_opening: Herb::Token?
-
-      attr_reader content: Herb::Token?
-
-      attr_reader tag_closing: Herb::Token?
-
-      attr_reader analyzed_ruby: nil
-
-      attr_reader prism_node: String?
-
       attr_reader partial: Herb::Token?
 
       attr_reader template_path: Herb::Token?
@@ -1588,8 +1576,71 @@ module Herb
 
       attr_reader locals: Array[Herb::AST::RubyRenderLocalNode]?
 
-      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Array[Herb::AST::RubyRenderLocalNode]) -> void
-      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Array[Herb::AST::RubyRenderLocalNode]) -> void
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Array[Herb::AST::RubyRenderLocalNode]) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Array[Herb::AST::RubyRenderLocalNode]) -> void
+
+      # : () -> serialized_ruby_render_keywords_node
+      def to_hash: () -> serialized_ruby_render_keywords_node
+
+      # : (Visitor) -> void
+      def accept: (Visitor) -> void
+
+      # : () -> Array[Herb::AST::Node?]
+      def child_nodes: () -> Array[Herb::AST::Node?]
+
+      # : () -> Array[Herb::AST::Node]
+      def compact_child_nodes: () -> Array[Herb::AST::Node]
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    # : type serialized_erb_render_node = {
+    # |  tag_opening: Herb::Token?,
+    # |  content: Herb::Token?,
+    # |  tag_closing: Herb::Token?,
+    # |  analyzed_ruby: nil,
+    # |  prism_node: String?,
+    # |  keywords: Herb::AST::RubyRenderKeywordsNode?,
+    # |  body: Array[Herb::AST::Node],
+    # |  block_arguments: Array[Herb::AST::RubyParameterNode]?,
+    # |  rescue_clause: Herb::AST::ERBRescueNode?,
+    # |  else_clause: Herb::AST::ERBElseNode?,
+    # |  ensure_clause: Herb::AST::ERBEnsureNode?,
+    # |  end_node: Herb::AST::ERBEndNode?,
+    # | }
+    class ERBRenderNode < Node
+      include Colors
+
+      attr_reader tag_opening: Herb::Token?
+
+      attr_reader content: Herb::Token?
+
+      attr_reader tag_closing: Herb::Token?
+
+      attr_reader analyzed_ruby: nil
+
+      attr_reader prism_node: String?
+
+      attr_reader keywords: Herb::AST::RubyRenderKeywordsNode?
+
+      attr_reader body: Array[Herb::AST::Node]
+
+      attr_reader block_arguments: Array[Herb::AST::RubyParameterNode]?
+
+      attr_reader rescue_clause: Herb::AST::ERBRescueNode?
+
+      attr_reader else_clause: Herb::AST::ERBElseNode?
+
+      attr_reader ensure_clause: Herb::AST::ERBEnsureNode?
+
+      attr_reader end_node: Herb::AST::ERBEndNode?
+
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Herb::AST::RubyRenderKeywordsNode, Array[Herb::AST::Node], Array[Herb::AST::RubyParameterNode], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Herb::AST::RubyRenderKeywordsNode, Array[Herb::AST::Node], Array[Herb::AST::RubyParameterNode], Herb::AST::ERBRescueNode, Herb::AST::ERBElseNode, Herb::AST::ERBEnsureNode, Herb::AST::ERBEndNode) -> void
 
       # : () -> Prism::node?
       def deserialized_prism_node: () -> Prism::node?
@@ -1613,28 +1664,28 @@ module Herb
       def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
     end
 
-    # : type serialized_ruby_strict_local_node = {
+    # : type serialized_ruby_parameter_node = {
     # |  name: Herb::Token?,
     # |  default_value: Herb::AST::RubyLiteralNode?,
+    # |  kind: String?,
     # |  required: bool,
-    # |  double_splat: bool,
     # | }
-    class RubyStrictLocalNode < Node
+    class RubyParameterNode < Node
       include Colors
 
       attr_reader name: Herb::Token?
 
       attr_reader default_value: Herb::AST::RubyLiteralNode?
 
-      attr_reader required: bool
+      attr_reader kind: String?
 
-      attr_reader double_splat: bool
+      attr_reader required: bool
 
-      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, bool, bool) -> void
-      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, bool, bool) -> void
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, String, bool) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode, String, bool) -> void
 
-      # : () -> serialized_ruby_strict_local_node
-      def to_hash: () -> serialized_ruby_strict_local_node
+      # : () -> serialized_ruby_parameter_node
+      def to_hash: () -> serialized_ruby_parameter_node
 
       # : (Visitor) -> void
       def accept: (Visitor) -> void
@@ -1658,7 +1709,7 @@ module Herb
     # |  tag_closing: Herb::Token?,
     # |  analyzed_ruby: nil,
     # |  prism_node: String?,
-    # |  locals: Array[Herb::AST::RubyStrictLocalNode]?,
+    # |  locals: Array[Herb::AST::RubyParameterNode]?,
     # | }
     class ERBStrictLocalsNode < Node
       include Colors
@@ -1673,10 +1724,10 @@ module Herb
 
       attr_reader prism_node: String?
 
-      attr_reader locals: Array[Herb::AST::RubyStrictLocalNode]?
+      attr_reader locals: Array[Herb::AST::RubyParameterNode]?
 
-      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Array[Herb::AST::RubyStrictLocalNode]) -> void
-      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Array[Herb::AST::RubyStrictLocalNode]) -> void
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Array[Herb::AST::RubyParameterNode]) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Array[Herb::AST::RubyParameterNode]) -> void
 
       # : () -> Prism::node?
       def deserialized_prism_node: () -> Prism::node?

data/sig/herb/visitor.rbs

@@ -130,11 +130,14 @@ module Herb
     # : (Herb::AST::RubyRenderLocalNode) -> void
     def visit_ruby_render_local_node: (Herb::AST::RubyRenderLocalNode) -> void
 
+    # : (Herb::AST::RubyRenderKeywordsNode) -> void
+    def visit_ruby_render_keywords_node: (Herb::AST::RubyRenderKeywordsNode) -> void
+
     # : (Herb::AST::ERBRenderNode) -> void
     def visit_erb_render_node: (Herb::AST::ERBRenderNode) -> void
 
-    # : (Herb::AST::RubyStrictLocalNode) -> void
-    def visit_ruby_strict_local_node: (Herb::AST::RubyStrictLocalNode) -> void
+    # : (Herb::AST::RubyParameterNode) -> void
+    def visit_ruby_parameter_node: (Herb::AST::RubyParameterNode) -> void
 
     # : (Herb::AST::ERBStrictLocalsNode) -> void
     def visit_erb_strict_locals_node: (Herb::AST::ERBStrictLocalsNode) -> void

data/sig/serialized_ast_nodes.rbs

@@ -170,6 +170,7 @@ module Herb
     tag_closing: Herb::Token,
     prism_node: String,
     body: Array[Herb::AST::Node],
+    block_arguments: Array[Herb::AST::RubyParameterNode],
     rescue_clause: Herb::AST::ERBRescueNode,
     else_clause: Herb::AST::ERBElseNode,
     ensure_clause: Herb::AST::ERBEnsureNode,
@@ -276,12 +277,7 @@ module Herb
     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,
+  type serialized_ruby_render_keywords_node = serialized_node & {
     partial: Herb::Token,
     template_path: Herb::Token,
     layout: Herb::Token,
@@ -302,11 +298,26 @@ module Herb
     locals: Array[Herb::AST::RubyRenderLocalNode],
   }
 
-  type serialized_ruby_strict_local_node = serialized_node & {
+  type serialized_erb_render_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    analyzed_ruby: nil,
+    prism_node: String,
+    keywords: Herb::AST::RubyRenderKeywordsNode,
+    body: Array[Herb::AST::Node],
+    block_arguments: Array[Herb::AST::RubyParameterNode],
+    rescue_clause: Herb::AST::ERBRescueNode,
+    else_clause: Herb::AST::ERBElseNode,
+    ensure_clause: Herb::AST::ERBEnsureNode,
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_ruby_parameter_node = serialized_node & {
     name: Herb::Token,
     default_value: Herb::AST::RubyLiteralNode,
+    kind: String,
     required: bool,
-    double_splat: bool,
   }
 
   type serialized_erb_strict_locals_node = serialized_node & {
@@ -315,7 +326,7 @@ module Herb
     tag_closing: Herb::Token,
     analyzed_ruby: nil,
     prism_node: String,
-    locals: Array[Herb::AST::RubyStrictLocalNode],
+    locals: Array[Herb::AST::RubyParameterNode],
   }
 
   type serialized_erb_yield_node = serialized_node & {

data/src/analyze/action_view/javascript_tag.c

@@ -1,4 +1,9 @@
 #include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../../include/ast/ast_nodes.h"
+#include "../../include/lib/hb_array.h"
+#include "../../include/lib/hb_string.h"
+#include "../../include/visitor.h"
 
 #include <prism.h>
 #include <stdbool.h>
@@ -45,6 +50,39 @@ bool javascript_tag_supports_block(void) {
   return true;
 }
 
+bool wrap_javascript_tag_body_visitor(const AST_NODE_T* node, void* data) {
+  hb_allocator_T* allocator = (hb_allocator_T*) data;
+
+  if (node == NULL || node->type != AST_HTML_ELEMENT_NODE) { return true; }
+
+  AST_HTML_ELEMENT_NODE_T* element = (AST_HTML_ELEMENT_NODE_T*) node;
+
+  if (!hb_string_equals(element->element_source, hb_string("ActionView::Helpers::JavaScriptHelper#javascript_tag"))) {
+    return true;
+  }
+
+  if (element->body == NULL || hb_array_size(element->body) == 0) { return false; }
+
+  for (size_t i = 0; i < hb_array_size(element->body); i++) {
+    AST_NODE_T* child = (AST_NODE_T*) hb_array_get(element->body, i);
+    if (child && child->type == AST_CDATA_NODE) { return false; }
+  }
+
+  hb_array_T* cdata_children = hb_array_init(hb_array_size(element->body), allocator);
+
+  for (size_t i = 0; i < hb_array_size(element->body); i++) {
+    hb_array_append(cdata_children, hb_array_get(element->body, i));
+  }
+
+  AST_CDATA_NODE_T* cdata_node =
+    create_javascript_cdata_node(cdata_children, element->base.location.start, element->base.location.end, allocator);
+
+  element->body->size = 0;
+  hb_array_append(element->body, (AST_NODE_T*) cdata_node);
+
+  return false;
+}
+
 const tag_helper_handler_T javascript_tag_handler = {
   .name = "javascript_tag",
   .source = HB_STRING_LITERAL("ActionView::Helpers::JavaScriptHelper#javascript_tag"),

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -124,7 +124,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node_precise(
       open_quote,
       value_children,
       close_quote,
-      positions->quoted,
+      true,
       positions->value_start,
       positions->value_end,
       hb_array_init(0, allocator),
@@ -179,7 +179,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal_precise(
     NULL,
     value_children,
     NULL,
-    false,
+    true,
     positions->content_start,
     positions->content_end,
     hb_array_init(0, allocator),
@@ -385,3 +385,24 @@ void append_body_content_node(
     if (text_node) { hb_array_append(body, (AST_NODE_T*) text_node); }
   }
 }
+
+AST_CDATA_NODE_T* create_javascript_cdata_node(
+  hb_array_T* children,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+) {
+  token_T* cdata_opening = create_synthetic_token(allocator, "\n//<![CDATA[\n", TOKEN_CDATA_START, start, end);
+
+  token_T* cdata_closing = create_synthetic_token(allocator, "\n//]]>\n", TOKEN_CDATA_END, start, end);
+
+  return ast_cdata_node_init(
+    cdata_opening,
+    children,
+    cdata_closing,
+    start,
+    end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+}

data/src/analyze/action_view/tag_helpers.c

@@ -639,7 +639,15 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
         id_is_ruby_expression ? create_html_attribute_with_ruby_literal("id", id_value, id_start, id_end, allocator)
                               : create_html_attribute_node("id", id_value, id_start, id_end, allocator);
 
-      if (id_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) id_attribute, allocator); }
+      if (id_attribute) {
+        AST_NODE_T* src_node = remove_attribute_by_name(attributes, "src");
+        AST_NODE_T* target_node = remove_attribute_by_name(attributes, "target");
+
+        hb_array_append(attributes, (AST_NODE_T*) id_attribute);
+
+        if (src_node) { hb_array_append(attributes, src_node); }
+        if (target_node) { hb_array_append(attributes, target_node); }
+      }
 
       hb_allocator_dealloc(allocator, id_value);
     }
@@ -679,7 +687,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
           ? create_html_attribute_node("src", source_attribute_value, source_start, source_end, allocator)
           : create_html_attribute_with_ruby_literal("src", source_attribute_value, source_start, source_end, allocator);
 
-      if (source_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) source_attribute, allocator); }
+      if (source_attribute) { hb_array_append(attributes, (AST_NODE_T*) source_attribute); }
 
       if (source_attribute_value != source_value) { hb_allocator_dealloc(allocator, source_attribute_value); }
       hb_allocator_dealloc(allocator, source_value);
@@ -723,7 +731,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
           ? create_html_attribute_node("src", source_attribute_value, source_start, source_end, allocator)
           : create_html_attribute_with_ruby_literal("src", source_attribute_value, source_start, source_end, allocator);
 
-      if (source_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) source_attribute, allocator); }
+      if (source_attribute) { hb_array_append(attributes, (AST_NODE_T*) source_attribute); }
       if (source_attribute_value != source_value) { hb_allocator_dealloc(allocator, source_attribute_value); }
 
       hb_allocator_dealloc(allocator, source_value);
@@ -798,14 +806,37 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
       );
     }
 
-    append_body_content_node(
-      body,
-      helper_content,
-      content_is_ruby_expression,
-      erb_node->base.location.start,
-      erb_node->base.location.end,
-      allocator
-    );
+    if (string_equals(handler->name, "javascript_tag")) {
+      hb_array_T* cdata_children = hb_array_init(1, allocator);
+
+      append_body_content_node(
+        cdata_children,
+        helper_content,
+        content_is_ruby_expression,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+
+      AST_CDATA_NODE_T* cdata_node = create_javascript_cdata_node(
+        cdata_children,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+
+      if (cdata_node) { hb_array_append(body, (AST_NODE_T*) cdata_node); }
+    } else {
+      append_body_content_node(
+        body,
+        helper_content,
+        content_is_ruby_expression,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+    }
+
     hb_allocator_dealloc(allocator, helper_content);
   }
 
@@ -1117,7 +1148,7 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
       AST_HTML_ATTRIBUTE_NODE_T* href_attribute =
         create_href_attribute(href, href_is_ruby_expression, href_start, href_end, allocator);
 
-      if (href_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) href_attribute, allocator); }
+      if (href_attribute) { hb_array_append(attributes, (AST_NODE_T*) href_attribute); }
 
       hb_allocator_dealloc(allocator, href);
     }
@@ -1138,7 +1169,15 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
         id_is_ruby_expression ? create_html_attribute_with_ruby_literal("id", id_value, id_start, id_end, allocator)
                               : create_html_attribute_node("id", id_value, id_start, id_end, allocator);
 
-      if (id_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) id_attribute, allocator); }
+      if (id_attribute) {
+        AST_NODE_T* src_node = remove_attribute_by_name(attributes, "src");
+        AST_NODE_T* target_node = remove_attribute_by_name(attributes, "target");
+
+        hb_array_append(attributes, (AST_NODE_T*) id_attribute);
+
+        if (src_node) { hb_array_append(attributes, src_node); }
+        if (target_node) { hb_array_append(attributes, target_node); }
+      }
 
       hb_allocator_dealloc(allocator, id_value);
     }
@@ -1395,7 +1434,7 @@ static AST_NODE_T* transform_link_to_helper(
     AST_HTML_ATTRIBUTE_NODE_T* href_attribute =
       create_href_attribute(href, href_is_ruby_expression, href_start, href_end, allocator);
 
-    if (href_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) href_attribute, allocator); }
+    if (href_attribute) { hb_array_append(attributes, (AST_NODE_T*) href_attribute); }
     if (!info->content) {
       href_for_body = hb_allocator_strdup(allocator, href);
       href_for_body_is_ruby_expression = href_is_ruby_expression;

data/src/analyze/analyze.c

@@ -736,12 +736,32 @@ static size_t process_block_structure(
   hb_array_T* block_errors = erb_node->base.errors;
   erb_node->base.errors = NULL;
 
+  // Filter out "incomplete block" Prism errors since we've matched the block with its end tag.
+  if (block_errors) {
+    for (size_t error_index = hb_array_size(block_errors); error_index > 0; error_index--) {
+      ERROR_T* error = hb_array_get(block_errors, error_index - 1);
+      if (!error || error->type != RUBY_PARSE_ERROR) { continue; }
+
+      RUBY_PARSE_ERROR_T* parse_error = (RUBY_PARSE_ERROR_T*) error;
+
+      if (string_equals(parse_error->diagnostic_id.data, "block_term_end")
+          || string_equals(parse_error->diagnostic_id.data, "block_term_brace")
+          || string_equals(parse_error->diagnostic_id.data, "unexpected_token_close_context")) {
+        hb_array_remove(block_errors, error_index - 1);
+      }
+    }
+  }
+
+  hb_array_T* block_arguments =
+    extract_block_arguments_from_erb_node(erb_node, context->source, block_errors, allocator);
+
   AST_ERB_BLOCK_NODE_T* block_node = ast_erb_block_node_init(
     erb_node->tag_opening,
     erb_node->content,
     erb_node->tag_closing,
     HERB_PRISM_NODE_EMPTY,
     children,
+    block_arguments,
     rescue_clause,
     else_clause,
     ensure_clause,
@@ -942,6 +962,7 @@ hb_array_T* get_node_children_array(const AST_NODE_T* node) {
     case AST_ERB_ENSURE_NODE: return ((AST_ERB_ENSURE_NODE_T*) node)->statements;
     case AST_ERB_CASE_NODE: return ((AST_ERB_CASE_NODE_T*) node)->children;
     case AST_ERB_WHEN_NODE: return ((AST_ERB_WHEN_NODE_T*) node)->statements;
+    case AST_ERB_RENDER_NODE: return ((AST_ERB_RENDER_NODE_T*) node)->body;
     default: return NULL;
   }
 }