herb 0.10.4-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/src/analyze/render_nodes.c

@@ -3,6 +3,7 @@
 #include "../include/analyze/action_view/tag_helpers.h"
 #include "../include/analyze/analyze.h"
 #include "../include/analyze/helpers.h"
+#include "../include/analyze/herb_directives.h"
 #include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
 #include "../include/lexer/token.h"
@@ -36,15 +37,18 @@ typedef struct {
   token_T** target;
 } keyword_field_T;
 
-// actionview/lib/action_view/render_parser.rb
+// A superset of ALL_KNOWN_KEYS in actionview/lib/action_view/render_parser.rb,
+// which only lists the keys Rails' dependency tracker will not bail out on. The
+// rendering modes and the collection options are recognized here as well.
 static const char* render_keywords[] = {
-  "partial", "template",   "layout",   "file",       "inline",       "body",     "plain",
-  "html",    "renderable", "locals",   "collection", "object",       "as",       "spacer_template",
-  "formats", "variants",   "handlers", "status",     "content_type", "location", NULL
+  "partial",      "template",   "layout", "file", "inline",          "body",    "plain",    "html",     "renderable",
+  "locals",       "collection", "object", "as",   "spacer_template", "formats", "variants", "handlers", "status",
+  "content_type", "location",   "cached", NULL
 };
 
 static bool is_render_call(pm_call_node_t* call_node, pm_parser_t* parser) {
   if (!call_node || !call_node->name) { return false; }
+  if (call_node->receiver && call_node->receiver->type != PM_SELF_NODE) { return false; }
 
   pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
 
@@ -214,6 +218,102 @@ static pm_hash_node_t* find_locals_hash(pm_keyword_hash_node_t* keyword_hash, hb
   return NULL;
 }
 
+static bool extract_assoc_parts(
+  pm_assoc_node_t* assoc,
+  const char* source,
+  size_t erb_content_offset,
+  const uint8_t* erb_content_source,
+  hb_allocator_T* allocator,
+  token_T** name_token,
+  AST_RUBY_LITERAL_NODE_T** value_node
+) {
+  char* name = extract_string_value(assoc->key, allocator);
+  if (!name) { name = extract_source_expression(assoc->key, allocator); }
+  if (!name) { return false; }
+
+  bool shorthand = assoc->value && assoc->value->type == PM_IMPLICIT_NODE;
+  char* value = shorthand ? hb_allocator_strdup(allocator, name) : extract_source_expression(assoc->value, allocator);
+
+  if (!value) {
+    hb_allocator_dealloc(allocator, name);
+    return false;
+  }
+
+  *name_token = create_token_from_prism_node(
+    assoc->key,
+    name,
+    TOKEN_IDENTIFIER,
+    source,
+    erb_content_offset,
+    erb_content_source,
+    allocator
+  );
+
+  position_T value_start = { .line = 1, .column = 1 };
+  position_T value_end = value_start;
+  pm_node_t* spanned = shorthand ? assoc->key : assoc->value;
+
+  if (spanned && source && erb_content_source) {
+    size_t start_offset = (size_t) (spanned->location.start - erb_content_source);
+    size_t end_offset = (size_t) (spanned->location.end - erb_content_source);
+
+    if (shorthand && end_offset > start_offset && erb_content_source[end_offset - 1] == ':') { end_offset--; }
+
+    value_start = byte_offset_to_position(source, erb_content_offset + start_offset);
+    value_end = byte_offset_to_position(source, erb_content_offset + end_offset);
+  }
+
+  *value_node = ast_ruby_literal_node_init(
+    hb_string_from_c_string(value),
+    value_start,
+    value_end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  hb_allocator_dealloc(allocator, name);
+  hb_allocator_dealloc(allocator, value);
+
+  return true;
+}
+
+static void append_local_from_assoc(
+  hb_array_T* locals,
+  pm_assoc_node_t* assoc,
+  const char* source,
+  size_t erb_content_offset,
+  const uint8_t* erb_content_source,
+  hb_allocator_T* allocator
+) {
+  token_T* name_token = NULL;
+  AST_RUBY_LITERAL_NODE_T* value_node = NULL;
+
+  if (!extract_assoc_parts(
+        assoc,
+        source,
+        erb_content_offset,
+        erb_content_source,
+        allocator,
+        &name_token,
+        &value_node
+      )) {
+    return;
+  }
+
+  position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
+
+  AST_RUBY_RENDER_LOCAL_NODE_T* local_node = ast_ruby_render_local_node_init(
+    name_token,
+    value_node,
+    start,
+    value_node->base.location.end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  hb_array_append(locals, local_node);
+}
+
 static hb_array_T* extract_locals_from_hash(
   pm_hash_node_t* hash,
   const char* source,
@@ -227,56 +327,14 @@ static hb_array_T* extract_locals_from_hash(
     pm_node_t* element = hash->elements.nodes[index];
     if (element->type != PM_ASSOC_NODE) { continue; }
 
-    pm_assoc_node_t* assoc = (pm_assoc_node_t*) element;
-    char* name = extract_string_value(assoc->key, allocator);
-    if (!name) { name = extract_source_expression(assoc->key, allocator); }
-    if (!name) { continue; }
-
-    char* value = extract_source_expression(assoc->value, allocator);
-
-    if (!value) {
-      hb_allocator_dealloc(allocator, name);
-      continue;
-    }
-
-    token_T* name_token = create_token_from_prism_node(
-      assoc->key,
-      name,
-      TOKEN_IDENTIFIER,
+    append_local_from_assoc(
+      locals,
+      (pm_assoc_node_t*) element,
       source,
       erb_content_offset,
       erb_content_source,
       allocator
     );
-
-    position_T value_start = { .line = 1, .column = 1 };
-    position_T value_end = value_start;
-
-    if (assoc->value && source && erb_content_source) {
-      size_t start_offset = (size_t) (assoc->value->location.start - erb_content_source);
-      size_t end_offset = (size_t) (assoc->value->location.end - erb_content_source);
-      value_start = byte_offset_to_position(source, erb_content_offset + start_offset);
-      value_end = byte_offset_to_position(source, erb_content_offset + end_offset);
-    }
-
-    AST_RUBY_LITERAL_NODE_T* value_node = ast_ruby_literal_node_init(
-      hb_string_from_c_string(value),
-      value_start,
-      value_end,
-      hb_array_init(0, allocator),
-      allocator
-    );
-
-    position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-    position_T end = value_end;
-
-    AST_RUBY_RENDER_LOCAL_NODE_T* local_node =
-      ast_ruby_render_local_node_init(name_token, value_node, start, end, hb_array_init(0, allocator), allocator);
-
-    hb_array_append(locals, local_node);
-
-    hb_allocator_dealloc(allocator, name);
-    hb_allocator_dealloc(allocator, value);
   }
 
   return locals;
@@ -307,6 +365,163 @@ static token_T* extract_keyword_token(
   return token;
 }
 
+static bool is_state_binding_assoc(pm_assoc_node_t* assoc, hb_allocator_T* allocator, const parser_options_T* options) {
+  if (!options || !options->herb_directives) { return false; }
+  if (!assoc->value || assoc->value->type != PM_HASH_NODE) { return false; }
+
+  char* key = extract_string_value(assoc->key, allocator);
+  if (!key) { return false; }
+
+  bool matches = string_equals(key, "state");
+  hb_allocator_dealloc(allocator, key);
+
+  return matches;
+}
+
+static pm_assoc_node_t* find_state_assoc(
+  pm_keyword_hash_node_t* keyword_hash,
+  hb_allocator_T* allocator,
+  const parser_options_T* options
+) {
+  if (!keyword_hash) { return NULL; }
+
+  for (size_t index = 0; index < keyword_hash->elements.size; index++) {
+    pm_node_t* element = keyword_hash->elements.nodes[index];
+    if (element->type != PM_ASSOC_NODE) { continue; }
+
+    pm_assoc_node_t* assoc = (pm_assoc_node_t*) element;
+    if (is_state_binding_assoc(assoc, allocator, options)) { return assoc; }
+  }
+
+  return NULL;
+}
+
+static void append_unusable_state_entry(
+  hb_array_T* entries,
+  pm_node_t* element,
+  const char* source,
+  size_t erb_content_offset,
+  const uint8_t* erb_content_source,
+  hb_allocator_T* allocator
+) {
+  pm_node_t* named = element->type == PM_ASSOC_NODE ? ((pm_assoc_node_t*) element)->key : element;
+  char* name = extract_source_expression(named, allocator);
+
+  if (!name) { return; }
+
+  token_T* name_token = create_token_from_prism_node(
+    named,
+    name,
+    TOKEN_IDENTIFIER,
+    source,
+    erb_content_offset,
+    erb_content_source,
+    allocator
+  );
+
+  position_T start = { .line = 1, .column = 1 };
+  position_T end = start;
+
+  if (source && erb_content_source) {
+    size_t start_offset = (size_t) (element->location.start - erb_content_source);
+    size_t end_offset = (size_t) (element->location.end - erb_content_source);
+
+    start = byte_offset_to_position(source, erb_content_offset + start_offset);
+    end = byte_offset_to_position(source, erb_content_offset + end_offset);
+  }
+
+  hb_array_append(
+    entries,
+    ast_herb_state_declaration_node_init(
+      name_token,
+      NULL,
+      herb_directive_kind_for_prism_node(NULL),
+      start,
+      end,
+      hb_array_init(0, allocator),
+      allocator
+    )
+  );
+
+  hb_allocator_dealloc(allocator, name);
+}
+
+static hb_array_T* extract_state_entries(
+  pm_assoc_node_t* state_assoc,
+  const char* source,
+  size_t erb_content_offset,
+  const uint8_t* erb_content_source,
+  hb_allocator_T* allocator
+) {
+  if (!state_assoc) { return hb_array_init(0, allocator); }
+
+  pm_hash_node_t* hash = (pm_hash_node_t*) state_assoc->value;
+  hb_array_T* entries = hb_array_init(hash->elements.size, allocator);
+
+  for (size_t index = 0; index < hash->elements.size; index++) {
+    pm_node_t* element = hash->elements.nodes[index];
+
+    if (element->type != PM_ASSOC_NODE || ((pm_assoc_node_t*) element)->key->type != PM_SYMBOL_NODE) {
+      append_unusable_state_entry(entries, element, source, erb_content_offset, erb_content_source, allocator);
+      continue;
+    }
+
+    pm_assoc_node_t* assoc = (pm_assoc_node_t*) element;
+    token_T* name_token = NULL;
+    AST_RUBY_LITERAL_NODE_T* value_node = NULL;
+
+    if (!extract_assoc_parts(
+          assoc,
+          source,
+          erb_content_offset,
+          erb_content_source,
+          allocator,
+          &name_token,
+          &value_node
+        )) {
+      continue;
+    }
+
+    position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
+    pm_node_t* value = assoc->value;
+
+    if (value->type == PM_IMPLICIT_NODE) { value = ((pm_implicit_node_t*) value)->value; }
+
+    AST_HERB_STATE_DECLARATION_NODE_T* entry = ast_herb_state_declaration_node_init(
+      name_token,
+      value_node,
+      herb_directive_kind_for_prism_node(value),
+      start,
+      value_node->base.location.end,
+      hb_array_init(0, allocator),
+      allocator
+    );
+
+    hb_array_append(entries, entry);
+  }
+
+  return entries;
+}
+
+static location_T* prism_node_location(
+  pm_node_t* node,
+  const char* source,
+  size_t erb_content_offset,
+  const uint8_t* erb_content_source,
+  hb_allocator_T* allocator
+) {
+  if (!node || !source || !erb_content_source) { return NULL; }
+
+  size_t start_offset = (size_t) (node->location.start - erb_content_source);
+  size_t end_offset = (size_t) (node->location.end - erb_content_source);
+
+  return location_create(
+    byte_offset_to_position(source, erb_content_offset + start_offset),
+    byte_offset_to_position(source, erb_content_offset + end_offset),
+    allocator
+  );
+}
+
 typedef struct {
   hb_array_T* block_body;
   hb_array_T* block_arguments;
@@ -324,7 +539,8 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
   size_t erb_content_offset,
   const uint8_t* erb_content_source,
   render_block_fields_T* block_fields,
-  hb_allocator_T* allocator
+  hb_allocator_T* allocator,
+  const parser_options_T* options
 ) {
 
   pm_arguments_node_t* arguments = call_node->arguments;
@@ -348,6 +564,11 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
   token_T* handlers = NULL;
   token_T* content_type = NULL;
 
+  pm_assoc_node_t* state_assoc = find_state_assoc(keyword_hash, allocator, options);
+  hb_array_T* state = extract_state_entries(state_assoc, source, erb_content_offset, erb_content_source, allocator);
+  location_T* state_location =
+    prism_node_location((pm_node_t*) state_assoc, source, erb_content_offset, erb_content_source, allocator);
+
   hb_array_T* locals = NULL;
   bool has_keyword_partial = false;
   bool has_positional_partial = false;
@@ -406,61 +627,16 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
         for (size_t index = 0; index < keyword_hash->elements.size; index++) {
           pm_node_t* element = keyword_hash->elements.nodes[index];
           if (element->type != PM_ASSOC_NODE) { continue; }
+          if (element == (pm_node_t*) state_assoc) { continue; }
 
-          pm_assoc_node_t* assoc = (pm_assoc_node_t*) element;
-          char* name = extract_string_value(assoc->key, allocator);
-          if (!name) { name = extract_source_expression(assoc->key, allocator); }
-          if (!name) { continue; }
-
-          char* value = extract_source_expression(assoc->value, allocator);
-
-          if (!value) {
-            hb_allocator_dealloc(allocator, name);
-            continue;
-          }
-
-          token_T* name_token = create_token_from_prism_node(
-            assoc->key,
-            name,
-            TOKEN_IDENTIFIER,
+          append_local_from_assoc(
+            locals,
+            (pm_assoc_node_t*) element,
             source,
             erb_content_offset,
             erb_content_source,
             allocator
           );
-
-          position_T value_start = { .line = 1, .column = 1 };
-          position_T value_end = value_start;
-
-          if (assoc->value && source && erb_content_source) {
-            size_t start_offset = (size_t) (assoc->value->location.start - erb_content_source);
-            size_t end_offset = (size_t) (assoc->value->location.end - erb_content_source);
-            value_start = byte_offset_to_position(source, erb_content_offset + start_offset);
-            value_end = byte_offset_to_position(source, erb_content_offset + end_offset);
-          }
-
-          AST_RUBY_LITERAL_NODE_T* value_node = ast_ruby_literal_node_init(
-            hb_string_from_c_string(value),
-            value_start,
-            value_end,
-            hb_array_init(0, allocator),
-            allocator
-          );
-
-          position_T start = name_token ? name_token->location.start : (position_T) { .line = 1, .column = 1 };
-
-          AST_RUBY_RENDER_LOCAL_NODE_T* local_node = ast_ruby_render_local_node_init(
-            name_token,
-            value_node,
-            start,
-            value_end,
-            hb_array_init(0, allocator),
-            allocator
-          );
-
-          hb_array_append(locals, local_node);
-          hb_allocator_dealloc(allocator, name);
-          hb_allocator_dealloc(allocator, value);
         }
       }
     } else {
@@ -485,7 +661,7 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
       };
 
       for (size_t index = 0; index < sizeof(keyword_fields) / sizeof(keyword_fields[0]); index++) {
-        *keyword_fields[index].target = extract_keyword_token(
+        token_T* keyword_token = extract_keyword_token(
           keyword_hash,
           keyword_fields[index].name,
           source,
@@ -493,6 +669,11 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
           erb_content_source,
           allocator
         );
+
+        if (keyword_token) {
+          token_free(*keyword_fields[index].target, allocator);
+          *keyword_fields[index].target = keyword_token;
+        }
       }
 
       if (partial) { has_keyword_partial = true; }
@@ -507,7 +688,7 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
 
   if (!locals) { locals = hb_array_init(0, allocator); }
 
-  hb_array_T* errors = hb_array_init(0, allocator);
+  hb_array_T* errors = NULL;
 
   if (!has_keyword_partial && partial && keyword_hash) {
     keyword_result_T locals_keyword = find_keyword_value(keyword_hash, "locals", allocator);
@@ -520,7 +701,8 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
         erb_node->base.location.start,
         erb_node->base.location.end,
         allocator,
-        errors
+        &errors,
+        options
       );
 
       hb_allocator_dealloc(allocator, locals_keyword.value);
@@ -548,6 +730,8 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
         }
       }
 
+      if (!is_known && assoc == state_assoc) { is_known = true; }
+
       if (!is_known) {
         has_non_render_kwargs = true;
         keywords_length += strlen(key) + 2;
@@ -593,7 +777,8 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
         erb_node->base.location.start,
         erb_node->base.location.end,
         allocator,
-        errors
+        &errors,
+        options
       );
 
       hb_allocator_dealloc(allocator, keywords_buffer);
@@ -602,7 +787,13 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
 
   if (!partial && !template_path && !layout && !file && !inline_template && !body && !plain && !html && !renderable
       && !has_positional_partial && !object) {
-    append_render_no_arguments_error(erb_node->base.location.start, erb_node->base.location.end, allocator, errors);
+    append_render_no_arguments_error(
+      erb_node->base.location.start,
+      erb_node->base.location.end,
+      allocator,
+      &errors,
+      options
+    );
   }
 
   if (has_positional_partial && has_keyword_partial && keyword_hash) {
@@ -614,7 +805,8 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
       erb_node->base.location.start,
       erb_node->base.location.end,
       allocator,
-      errors
+      &errors,
+      options
     );
 
     if (keyword_partial.value) { hb_allocator_dealloc(allocator, keyword_partial.value); }
@@ -642,7 +834,8 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
         erb_node->base.location.start,
         erb_node->base.location.end,
         allocator,
-        errors
+        &errors,
+        options
       );
     }
   }
@@ -652,17 +845,19 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
       erb_node->base.location.start,
       erb_node->base.location.end,
       allocator,
-      errors
+      &errors,
+      options
     );
   }
 
-  if (layout && !partial && !template_path) {
+  if (layout && !partial && !template_path && !(block_fields && block_fields->end_node)) {
     append_render_layout_without_block_error(
       layout->value,
       erb_node->base.location.start,
       erb_node->base.location.end,
       allocator,
-      errors
+      &errors,
+      options
     );
   }
 
@@ -676,9 +871,6 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
   AST_ERB_ENSURE_NODE_T* render_ensure_clause = block_fields ? block_fields->ensure_clause : NULL;
   AST_ERB_END_NODE_T* render_end_node = block_fields ? block_fields->end_node : NULL;
 
-  if (!render_block_body) { render_block_body = hb_array_init(0, allocator); }
-  if (!render_block_arguments) { render_block_arguments = hb_array_init(0, allocator); }
-
   if (!block_fields) {
     pm_block_node_t* inline_block = find_block_on_render_call(call_node);
 
@@ -688,6 +880,8 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
       if (inline_block->parameters && inline_block->parameters->type == PM_BLOCK_PARAMETERS_NODE) {
         pm_block_parameters_node_t* block_parameters = (pm_block_parameters_node_t*) inline_block->parameters;
 
+        hb_array_free(&render_block_arguments);
+
         render_block_arguments = extract_parameters_from_prism(
           block_parameters->parameters,
           parser,
@@ -721,6 +915,8 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
           allocator
         );
 
+        hb_array_free(&render_block_body);
+
         render_block_body = hb_array_init(1, allocator);
         hb_array_append(render_block_body, body_node);
 
@@ -748,16 +944,21 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
     handlers,
     content_type,
     locals,
+    state,
+    state_location,
     erb_node->base.location.start,
     erb_node->base.location.end,
     hb_array_init(0, allocator),
     allocator
   );
 
-  AST_ERB_RENDER_NODE_T* render_node = ast_erb_render_node_init(
-    erb_node->tag_opening,
-    erb_node->content,
-    erb_node->tag_closing,
+  if (!render_block_body) { render_block_body = hb_array_init(0, allocator); }
+  if (!render_block_arguments) { render_block_arguments = hb_array_init(0, allocator); }
+
+  return ast_erb_render_node_init(
+    token_copy(erb_node->tag_opening, allocator),
+    token_copy(erb_node->content, allocator),
+    token_copy(erb_node->tag_closing, allocator),
     erb_node->analyzed_ruby,
     prism_node,
     keywords_node,
@@ -772,8 +973,6 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
     errors,
     allocator
   );
-
-  return render_node;
 }
 
 static size_t calculate_byte_offset_from_pos(const char* source, position_T position) {
@@ -802,8 +1001,7 @@ static size_t calculate_byte_offset_from_pos(const char* source, position_T posi
 static bool is_erb_comment_tag(token_T* tag_opening) {
   if (!tag_opening || hb_string_is_empty(tag_opening->value)) { return false; }
 
-  const char* opening_string = tag_opening->value.data;
-  return opening_string && strstr(opening_string, "#") != NULL;
+  return hb_string_contains_character(tag_opening->value, '#');
 }
 
 static AST_ERB_RENDER_NODE_T* try_transform_content_node(
@@ -833,7 +1031,8 @@ static AST_ERB_RENDER_NODE_T* try_transform_content_node(
     erb_content_offset,
     erb_content_source,
     NULL,
-    context->allocator
+    context->allocator,
+    context->options
   );
 }
 
@@ -895,7 +1094,8 @@ static AST_ERB_RENDER_NODE_T* try_transform_block_node(
     erb_content_offset,
     erb_content_source,
     &block_fields,
-    context->allocator
+    context->allocator,
+    context->options
   );
 
   pm_node_destroy(&parser, root);
@@ -904,6 +1104,25 @@ static AST_ERB_RENDER_NODE_T* try_transform_block_node(
   return render_node;
 }
 
+static void release_replaced_node(AST_NODE_T* child, AST_ERB_RENDER_NODE_T* render_node, hb_allocator_T* allocator) {
+  if (child->type == AST_ERB_CONTENT_NODE) {
+    AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) child;
+
+    if (render_node->analyzed_ruby == erb_node->analyzed_ruby) { erb_node->analyzed_ruby = NULL; }
+  } else if (child->type == AST_ERB_BLOCK_NODE) {
+    AST_ERB_BLOCK_NODE_T* block_node = (AST_ERB_BLOCK_NODE_T*) child;
+
+    if (render_node->body == block_node->body) { block_node->body = NULL; }
+    if (render_node->block_arguments == block_node->block_arguments) { block_node->block_arguments = NULL; }
+    if (render_node->rescue_clause == block_node->rescue_clause) { block_node->rescue_clause = NULL; }
+    if (render_node->else_clause == block_node->else_clause) { block_node->else_clause = NULL; }
+    if (render_node->ensure_clause == block_node->ensure_clause) { block_node->ensure_clause = NULL; }
+    if (render_node->end_node == block_node->end_node) { block_node->end_node = NULL; }
+  }
+
+  ast_node_free(child, allocator);
+}
+
 static void transform_render_nodes_in_array(hb_array_T* array, analyze_ruby_context_T* context) {
   if (!array) { return; }
 
@@ -919,7 +1138,10 @@ static void transform_render_nodes_in_array(hb_array_T* array, analyze_ruby_cont
       render_node = try_transform_block_node((AST_ERB_BLOCK_NODE_T*) child, context);
     }
 
-    if (render_node) { hb_array_set(array, index, render_node); }
+    if (render_node) {
+      hb_array_set(array, index, render_node);
+      release_replaced_node(child, render_node, context->allocator);
+    }
   }
 }