herb 0.9.4-aarch64-linux-gnu → 0.9.6-aarch64-linux-gnu

data/src/analyze/postfix_conditionals.c

@@ -0,0 +1,326 @@
+#include "../include/analyze/postfix_conditionals.h"
+#include "../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../include/analyze/analyze.h"
+#include "../include/analyze/analyzed_ruby.h"
+#include "../include/analyze/ternary_conditionals.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_string.h"
+#include "../include/prism/herb_prism_node.h"
+#include "../include/visitor.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <string.h>
+
+static bool is_erb_output_tag(AST_ERB_CONTENT_NODE_T* erb_node) {
+  if (!erb_node || !erb_node->tag_opening) { return false; }
+
+  hb_string_T opening = erb_node->tag_opening->value;
+
+  return opening.length >= 3 && opening.data[0] == '<' && opening.data[1] == '%' && opening.data[2] == '=';
+}
+
+static pm_node_t* find_postfix_conditional_statement(analyzed_ruby_T* analyzed) {
+  if (!analyzed || !analyzed->valid || !analyzed->root) { return NULL; }
+
+  if (analyzed->root->type != PM_PROGRAM_NODE) { return NULL; }
+  pm_program_node_t* program = (pm_program_node_t*) analyzed->root;
+
+  if (!program->statements || program->statements->body.size != 1) { return NULL; }
+  pm_node_t* statement = program->statements->body.nodes[0];
+
+  if (statement->type == PM_IF_NODE) {
+    pm_if_node_t* if_node = (pm_if_node_t*) statement;
+
+    if (if_node->if_keyword_loc.start != NULL && if_node->end_keyword_loc.start == NULL) { return statement; }
+  } else if (statement->type == PM_UNLESS_NODE) {
+    pm_unless_node_t* unless_node = (pm_unless_node_t*) statement;
+
+    if (unless_node->keyword_loc.start != NULL && unless_node->end_keyword_loc.start == NULL) { return statement; }
+  }
+
+  return NULL;
+}
+
+typedef struct {
+  char* source;
+  size_t offset_in_content;
+  size_t length;
+} body_info_T;
+
+static body_info_T extract_statements_body_info(
+  pm_statements_node_t* statements,
+  analyzed_ruby_T* analyzed,
+  hb_allocator_T* allocator
+) {
+  body_info_T info = { .source = NULL, .offset_in_content = 0, .length = 0 };
+
+  if (!statements || statements->body.size == 0) { return info; }
+
+  pm_node_t* first = statements->body.nodes[0];
+  pm_node_t* last = statements->body.nodes[statements->body.size - 1];
+
+  const uint8_t* start = first->location.start;
+  const uint8_t* end = last->location.end;
+
+  const uint8_t* parser_start = analyzed->parser.start;
+  size_t source_length = (size_t) (analyzed->parser.end - parser_start);
+
+  if (start < parser_start || end > parser_start + source_length) { return info; }
+
+  const uint8_t* body_start = start;
+  const uint8_t* body_end = end;
+
+  if (body_start > parser_start && *(body_start - 1) == ' ') { body_start--; }
+  if (body_end < parser_start + source_length && *body_end == ' ') { body_end++; }
+
+  info.offset_in_content = (size_t) (body_start - parser_start);
+  info.length = (size_t) (body_end - body_start);
+  info.source = hb_allocator_strndup(allocator, (const char*) body_start, info.length);
+
+  return info;
+}
+
+static body_info_T extract_body_info(
+  pm_node_t* conditional_node,
+  analyzed_ruby_T* analyzed,
+  hb_allocator_T* allocator
+) {
+  pm_statements_node_t* statements = NULL;
+
+  if (conditional_node->type == PM_IF_NODE) {
+    statements = ((pm_if_node_t*) conditional_node)->statements;
+  } else if (conditional_node->type == PM_UNLESS_NODE) {
+    statements = ((pm_unless_node_t*) conditional_node)->statements;
+  }
+
+  body_info_T info = extract_statements_body_info(statements, analyzed, allocator);
+
+  if (info.source) {
+    info.length = info.offset_in_content + info.length;
+    info.offset_in_content = 0;
+    info.source = hb_allocator_strndup(allocator, (const char*) analyzed->parser.start, info.length);
+  }
+
+  return info;
+}
+
+static char* extract_condition_source(pm_node_t* conditional_node, hb_allocator_T* allocator) {
+  pm_node_t* predicate = NULL;
+
+  if (conditional_node->type == PM_IF_NODE) {
+    predicate = ((pm_if_node_t*) conditional_node)->predicate;
+  } else if (conditional_node->type == PM_UNLESS_NODE) {
+    predicate = ((pm_unless_node_t*) conditional_node)->predicate;
+  }
+
+  if (!predicate) { return NULL; }
+
+  size_t length = (size_t) (predicate->location.end - predicate->location.start);
+
+  return hb_allocator_strndup(allocator, (const char*) predicate->location.start, length);
+}
+
+static const char* condition_keyword(pm_node_t* conditional_node) {
+  if (conditional_node->type == PM_IF_NODE) { return "if"; }
+  if (conditional_node->type == PM_UNLESS_NODE) { return "unless"; }
+
+  return NULL;
+}
+
+static pm_if_node_t* find_nested_ternary(pm_node_t* conditional_node) {
+  pm_statements_node_t* statements = NULL;
+
+  if (conditional_node->type == PM_IF_NODE) {
+    statements = ((pm_if_node_t*) conditional_node)->statements;
+  } else if (conditional_node->type == PM_UNLESS_NODE) {
+    statements = ((pm_unless_node_t*) conditional_node)->statements;
+  }
+
+  if (!statements || statements->body.size != 1) { return NULL; }
+
+  pm_node_t* body_node = statements->body.nodes[0];
+
+  if (body_node->type == PM_PARENTHESES_NODE) {
+    pm_parentheses_node_t* parens = (pm_parentheses_node_t*) body_node;
+
+    if (!parens->body || parens->body->type != PM_STATEMENTS_NODE) { return NULL; }
+
+    pm_statements_node_t* inner_statements = (pm_statements_node_t*) parens->body;
+
+    if (inner_statements->body.size != 1) { return NULL; }
+
+    body_node = inner_statements->body.nodes[0];
+  }
+
+  if (body_node->type != PM_IF_NODE) { return NULL; }
+
+  pm_if_node_t* if_node = (pm_if_node_t*) body_node;
+
+  if (if_node->if_keyword_loc.start == NULL && if_node->subsequent != NULL) { return if_node; }
+
+  return NULL;
+}
+
+static AST_NODE_T* transform_conditional(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  pm_node_t* conditional_node,
+  hb_allocator_T* allocator
+) {
+  body_info_T body_info = extract_body_info(conditional_node, erb_node->analyzed_ruby, allocator);
+  if (!body_info.source) { return NULL; }
+
+  char* condition_source = extract_condition_source(conditional_node, allocator);
+  if (!condition_source) { return NULL; }
+
+  const char* keyword = condition_keyword(conditional_node);
+  if (!keyword) { return NULL; }
+
+  position_T start = erb_node->base.location.start;
+  position_T end = erb_node->base.location.end;
+  position_T content_start = erb_node->content->location.start;
+
+  position_T body_content_start = { .line = content_start.line,
+                                    .column = content_start.column + (uint32_t) body_info.offset_in_content };
+
+  position_T body_content_end = { .line = content_start.line,
+                                  .column = content_start.column
+                                          + (uint32_t) (body_info.offset_in_content + body_info.length) };
+
+  token_T* body_content =
+    create_synthetic_token(allocator, body_info.source, TOKEN_ERB_CONTENT, body_content_start, body_content_end);
+
+  AST_ERB_CONTENT_NODE_T* body_erb_node = ast_erb_content_node_init(
+    erb_node->tag_opening,
+    body_content,
+    erb_node->tag_closing,
+    NULL,
+    false,
+    true,
+    HERB_PRISM_NODE_EMPTY,
+    start,
+    end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  if (!body_erb_node) { return NULL; }
+
+  hb_array_T* statements = hb_array_init(1, allocator);
+  hb_array_append(statements, (AST_NODE_T*) body_erb_node);
+
+  pm_if_node_t* nested_ternary = find_nested_ternary(conditional_node);
+
+  if (nested_ternary) {
+    AST_NODE_T* ternary_replacement = transform_ternary_expression(erb_node, nested_ternary, allocator);
+
+    if (ternary_replacement) { hb_array_set(statements, 0, ternary_replacement); }
+  }
+
+  hb_buffer_T condition_buffer;
+  hb_buffer_init(&condition_buffer, 64, allocator);
+  hb_buffer_append(&condition_buffer, " ");
+  hb_buffer_append(&condition_buffer, keyword);
+  hb_buffer_append(&condition_buffer, " ");
+  hb_buffer_append(&condition_buffer, condition_source);
+  hb_buffer_append(&condition_buffer, " ");
+
+  const char* condition_content = hb_buffer_value(&condition_buffer);
+
+  token_T* tag_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, start, start);
+  token_T* content_token = create_synthetic_token(allocator, condition_content, TOKEN_ERB_CONTENT, start, end);
+  token_T* tag_closing = create_synthetic_token(allocator, "%>", TOKEN_ERB_END, end, end);
+
+  token_T* end_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, end, end);
+  token_T* end_content = create_synthetic_token(allocator, " end ", TOKEN_ERB_CONTENT, end, end);
+  token_T* end_closing = create_synthetic_token(allocator, "%>", TOKEN_ERB_END, end, end);
+
+  AST_ERB_END_NODE_T* end_node =
+    ast_erb_end_node_init(end_opening, end_content, end_closing, end, end, hb_array_init(0, allocator), allocator);
+
+  herb_prism_node_T empty_prism_node = HERB_PRISM_NODE_EMPTY;
+
+  if (conditional_node->type == PM_IF_NODE) {
+    AST_ERB_IF_NODE_T* if_node = ast_erb_if_node_init(
+      tag_opening,
+      content_token,
+      tag_closing,
+      NULL,
+      empty_prism_node,
+      statements,
+      NULL,
+      end_node,
+      start,
+      end,
+      hb_array_init(0, allocator),
+      allocator
+    );
+
+    return (AST_NODE_T*) if_node;
+  } else {
+    AST_ERB_UNLESS_NODE_T* unless_node = ast_erb_unless_node_init(
+      tag_opening,
+      content_token,
+      tag_closing,
+      NULL,
+      empty_prism_node,
+      statements,
+      NULL,
+      end_node,
+      start,
+      end,
+      hb_array_init(0, allocator),
+      allocator
+    );
+
+    return (AST_NODE_T*) unless_node;
+  }
+}
+
+static void transform_conditional_array(hb_array_T* array, analyze_ruby_context_T* context) {
+  if (!array || !context) { return; }
+
+  for (size_t i = 0; i < hb_array_size(array); i++) {
+    AST_NODE_T* child = hb_array_get(array, i);
+    if (!child) { continue; }
+    if (child->type != AST_ERB_CONTENT_NODE) { continue; }
+
+    AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) child;
+    if (!is_erb_output_tag(erb_node)) { continue; }
+    if (!erb_node->analyzed_ruby) { continue; }
+
+    pm_node_t* conditional_node = find_postfix_conditional_statement(erb_node->analyzed_ruby);
+    if (!conditional_node) { continue; }
+
+    AST_NODE_T* replacement = transform_conditional(erb_node, conditional_node, context->allocator);
+    if (replacement) { hb_array_set(array, i, replacement); }
+  }
+}
+
+static void transform_conditional_blocks(const AST_NODE_T* node, analyze_ruby_context_T* context) {
+  if (!node || !context) { return; }
+
+  switch (node->type) {
+    case AST_DOCUMENT_NODE: transform_conditional_array(((AST_DOCUMENT_NODE_T*) node)->children, context); break;
+    case AST_HTML_ELEMENT_NODE: transform_conditional_array(((AST_HTML_ELEMENT_NODE_T*) node)->body, context); break;
+    case AST_HTML_OPEN_TAG_NODE:
+      transform_conditional_array(((AST_HTML_OPEN_TAG_NODE_T*) node)->children, context);
+      break;
+    case AST_HTML_ATTRIBUTE_VALUE_NODE:
+      transform_conditional_array(((AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node)->children, context);
+      break;
+    default: break;
+  }
+}
+
+bool transform_conditional_nodes(const AST_NODE_T* node, void* data) {
+  analyze_ruby_context_T* context = (analyze_ruby_context_T*) data;
+
+  transform_conditional_blocks(node, context);
+
+  herb_visit_child_nodes(node, transform_conditional_nodes, data);
+
+  return false;
+}

data/src/analyze/render_nodes.c

@@ -2,6 +2,7 @@
 #include "../include/analyze/action_view/tag_helper_node_builders.h"
 #include "../include/analyze/action_view/tag_helpers.h"
 #include "../include/analyze/analyze.h"
+#include "../include/analyze/helpers.h"
 #include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
 #include "../include/lib/hb_allocator.h"
@@ -14,6 +15,16 @@
 #include <stdbool.h>
 #include <string.h>
 
+static token_T* create_token_from_prism_node(
+  pm_node_t* node,
+  const char* value,
+  token_type_T type,
+  const char* source,
+  size_t erb_content_offset,
+  const uint8_t* erb_content_source,
+  hb_allocator_T* allocator
+);
+
 typedef struct {
   char* value;
   pm_node_t* value_node;
@@ -62,6 +73,27 @@ static pm_call_node_t* find_render_call(pm_node_t* node, pm_parser_t* parser) {
   return NULL;
 }
 
+static pm_block_node_t* find_block_on_render_call(pm_call_node_t* render_call) {
+  if (!render_call) { return NULL; }
+
+  if (render_call->block && render_call->block->type == PM_BLOCK_NODE) { return (pm_block_node_t*) render_call->block; }
+
+  pm_arguments_node_t* arguments = render_call->arguments;
+  if (!arguments || arguments->arguments.size == 0) { return NULL; }
+
+  pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+  if (first_argument->type == PM_CALL_NODE) {
+    pm_call_node_t* argument_call = (pm_call_node_t*) first_argument;
+
+    if (argument_call->block && argument_call->block->type == PM_BLOCK_NODE) {
+      return (pm_block_node_t*) argument_call->block;
+    }
+  }
+
+  return NULL;
+}
+
 static char* extract_string_value(pm_node_t* node, hb_allocator_T* allocator) {
   if (!node) { return NULL; }
 
@@ -274,6 +306,15 @@ static token_T* extract_keyword_token(
   return token;
 }
 
+typedef struct {
+  hb_array_T* block_body;
+  hb_array_T* block_arguments;
+  AST_ERB_RESCUE_NODE_T* rescue_clause;
+  AST_ERB_ELSE_NODE_T* else_clause;
+  AST_ERB_ENSURE_NODE_T* ensure_clause;
+  AST_ERB_END_NODE_T* end_node;
+} render_block_fields_T;
+
 static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
   AST_ERB_CONTENT_NODE_T* erb_node,
   pm_call_node_t* call_node,
@@ -281,9 +322,9 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
   const char* source,
   size_t erb_content_offset,
   const uint8_t* erb_content_source,
+  render_block_fields_T* block_fields,
   hb_allocator_T* allocator
 ) {
-  (void) parser;
 
   pm_arguments_node_t* arguments = call_node->arguments;
   pm_keyword_hash_node_t* keyword_hash = arguments ? find_keyword_hash(arguments) : NULL;
@@ -626,12 +667,68 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
 
   herb_prism_node_T prism_node = erb_node->prism_node;
 
-  AST_ERB_RENDER_NODE_T* render_node = ast_erb_render_node_init(
-    erb_node->tag_opening,
-    erb_node->content,
-    erb_node->tag_closing,
-    erb_node->analyzed_ruby,
-    prism_node,
+  hb_array_T* render_block_body = block_fields ? block_fields->block_body : NULL;
+  hb_array_T* render_block_arguments = block_fields ? block_fields->block_arguments : NULL;
+
+  AST_ERB_RESCUE_NODE_T* render_rescue_clause = block_fields ? block_fields->rescue_clause : NULL;
+  AST_ERB_ELSE_NODE_T* render_else_clause = block_fields ? block_fields->else_clause : NULL;
+  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);
+
+    if (inline_block) {
+      const uint8_t* content_source = erb_content_source ? erb_content_source : (const uint8_t*) parser->start;
+
+      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;
+
+        render_block_arguments = extract_parameters_from_prism(
+          block_parameters->parameters,
+          parser,
+          source,
+          erb_content_offset,
+          content_source,
+          allocator
+        );
+      }
+
+      if (inline_block->body) {
+        size_t body_length = (size_t) (inline_block->body->location.end - inline_block->body->location.start);
+        char* body_source =
+          hb_allocator_strndup(allocator, (const char*) inline_block->body->location.start, body_length);
+
+        position_T body_start = { .line = 1, .column = 1 };
+        position_T body_end = { .line = 1, .column = 1 };
+
+        if (source && content_source) {
+          size_t start_offset = (size_t) (inline_block->body->location.start - content_source);
+          size_t end_offset = (size_t) (inline_block->body->location.end - content_source);
+          body_start = byte_offset_to_position(source, erb_content_offset + start_offset);
+          body_end = byte_offset_to_position(source, erb_content_offset + end_offset);
+        }
+
+        AST_RUBY_LITERAL_NODE_T* body_node = ast_ruby_literal_node_init(
+          hb_string_from_c_string(body_source),
+          body_start,
+          body_end,
+          hb_array_init(0, allocator),
+          allocator
+        );
+
+        render_block_body = hb_array_init(1, allocator);
+        hb_array_append(render_block_body, body_node);
+
+        hb_allocator_dealloc(allocator, body_source);
+      }
+    }
+  }
+
+  AST_RUBY_RENDER_KEYWORDS_NODE_T* keywords_node = ast_ruby_render_keywords_node_init(
     partial,
     template_path,
     layout,
@@ -652,6 +749,25 @@ static AST_ERB_RENDER_NODE_T* create_render_node_from_call(
     locals,
     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,
+    erb_node->analyzed_ruby,
+    prism_node,
+    keywords_node,
+    render_block_body,
+    render_block_arguments,
+    render_rescue_clause,
+    render_else_clause,
+    render_ensure_clause,
+    render_end_node,
+    erb_node->base.location.start,
+    erb_node->base.location.end,
     errors,
     allocator
   );
@@ -682,43 +798,123 @@ static size_t calculate_byte_offset_from_pos(const char* source, position_T posi
   return offset;
 }
 
-static void transform_render_nodes_in_array(hb_array_T* array, analyze_ruby_context_T* context) {
-  if (!array) { return; }
+static bool is_erb_comment_tag(token_T* tag_opening) {
+  if (!tag_opening || hb_string_is_empty(tag_opening->value)) { return false; }
 
-  for (size_t index = 0; index < hb_array_size(array); index++) {
-    AST_NODE_T* child = hb_array_get(array, index);
-    if (!child || child->type != AST_ERB_CONTENT_NODE) { continue; }
+  const char* opening_string = tag_opening->value.data;
+  return opening_string && strstr(opening_string, "#") != NULL;
+}
 
-    AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) child;
+static AST_ERB_RENDER_NODE_T* try_transform_content_node(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  analyze_ruby_context_T* context
+) {
+  if (!erb_node->analyzed_ruby || !erb_node->analyzed_ruby->valid || !erb_node->analyzed_ruby->parsed) { return NULL; }
+  if (is_erb_comment_tag(erb_node->tag_opening)) { return NULL; }
 
-    if (!erb_node->analyzed_ruby || !erb_node->analyzed_ruby->valid || !erb_node->analyzed_ruby->parsed) { continue; }
+  pm_call_node_t* render_call = find_render_call(erb_node->analyzed_ruby->root, &erb_node->analyzed_ruby->parser);
+  if (!render_call) { return NULL; }
 
-    token_T* tag_opening = erb_node->tag_opening;
+  size_t erb_content_offset = 0;
 
-    if (tag_opening && !hb_string_is_empty(tag_opening->value)) {
-      const char* opening_string = tag_opening->value.data;
-      if (opening_string && strstr(opening_string, "#") != NULL) { continue; }
-    }
+  if (context->source && erb_node->content) {
+    erb_content_offset = calculate_byte_offset_from_pos(context->source, erb_node->content->location.start);
+  }
 
-    pm_call_node_t* render_call = find_render_call(erb_node->analyzed_ruby->root, &erb_node->analyzed_ruby->parser);
-    if (!render_call) { continue; }
+  const uint8_t* erb_content_source = (const uint8_t*) erb_node->analyzed_ruby->parser.start;
 
-    size_t erb_content_offset = 0;
-    if (context->source && erb_node->content) {
-      erb_content_offset = calculate_byte_offset_from_pos(context->source, erb_node->content->location.start);
-    }
+  return create_render_node_from_call(
+    erb_node,
+    render_call,
+    &erb_node->analyzed_ruby->parser,
+    context->source,
+    erb_content_offset,
+    erb_content_source,
+    NULL,
+    context->allocator
+  );
+}
+
+static AST_ERB_RENDER_NODE_T* try_transform_block_node(
+  AST_ERB_BLOCK_NODE_T* block_node,
+  analyze_ruby_context_T* context
+) {
+  if (!block_node->content || hb_string_is_empty(block_node->content->value)) { return NULL; }
 
-    const uint8_t* erb_content_source = (const uint8_t*) erb_node->analyzed_ruby->parser.start;
+  const char* ruby_source = block_node->content->value.data;
+  size_t ruby_length = block_node->content->value.length;
 
-    AST_ERB_RENDER_NODE_T* render_node = create_render_node_from_call(
-      erb_node,
-      render_call,
-      &erb_node->analyzed_ruby->parser,
-      context->source,
-      erb_content_offset,
-      erb_content_source,
-      context->allocator
-    );
+  pm_parser_t parser;
+  pm_parser_init(&parser, (const uint8_t*) ruby_source, ruby_length, NULL);
+  pm_node_t* root = pm_parse(&parser);
+
+  pm_call_node_t* render_call = find_render_call(root, &parser);
+
+  if (!render_call) {
+    pm_node_destroy(&parser, root);
+    pm_parser_free(&parser);
+    return NULL;
+  }
+
+  AST_ERB_CONTENT_NODE_T content_view = {
+    .base = block_node->base,
+    .tag_opening = block_node->tag_opening,
+    .content = block_node->content,
+    .tag_closing = block_node->tag_closing,
+    .analyzed_ruby = NULL,
+    .parsed = true,
+    .valid = true,
+    .prism_node = block_node->prism_node,
+  };
+
+  size_t erb_content_offset = 0;
+
+  if (context->source && block_node->content) {
+    erb_content_offset = calculate_byte_offset_from_pos(context->source, block_node->content->location.start);
+  }
+
+  const uint8_t* erb_content_source = (const uint8_t*) parser.start;
+
+  render_block_fields_T block_fields = {
+    .block_body = block_node->body,
+    .block_arguments = block_node->block_arguments,
+    .rescue_clause = block_node->rescue_clause,
+    .else_clause = block_node->else_clause,
+    .ensure_clause = block_node->ensure_clause,
+    .end_node = block_node->end_node,
+  };
+
+  AST_ERB_RENDER_NODE_T* render_node = create_render_node_from_call(
+    &content_view,
+    render_call,
+    &parser,
+    context->source,
+    erb_content_offset,
+    erb_content_source,
+    &block_fields,
+    context->allocator
+  );
+
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+
+  return render_node;
+}
+
+static void transform_render_nodes_in_array(hb_array_T* array, analyze_ruby_context_T* context) {
+  if (!array) { return; }
+
+  for (size_t index = 0; index < hb_array_size(array); index++) {
+    AST_NODE_T* child = hb_array_get(array, index);
+    if (!child) { continue; }
+
+    AST_ERB_RENDER_NODE_T* render_node = NULL;
+
+    if (child->type == AST_ERB_CONTENT_NODE) {
+      render_node = try_transform_content_node((AST_ERB_CONTENT_NODE_T*) child, context);
+    } else if (child->type == AST_ERB_BLOCK_NODE) {
+      render_node = try_transform_block_node((AST_ERB_BLOCK_NODE_T*) child, context);
+    }
 
     if (render_node) { hb_array_set(array, index, render_node); }
   }