herb 0.9.2-arm-linux-gnu → 0.9.4-arm-linux-gnu

data/src/analyze/analyze.c

@@ -9,16 +9,17 @@
 #include "../include/analyze/helpers.h"
 #include "../include/analyze/invalid_structures.h"
 #include "../include/analyze/render_nodes.h"
-#include "../include/ast_node.h"
-#include "../include/ast_nodes.h"
+#include "../include/analyze/strict_locals.h"
+#include "../include/ast/ast_node.h"
+#include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
-#include "../include/location.h"
-#include "../include/parser.h"
-#include "../include/position.h"
-#include "../include/token_struct.h"
-#include "../include/util/hb_array.h"
-#include "../include/util/hb_string.h"
-#include "../include/util/string.h"
+#include "../include/lexer/token_struct.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_string.h"
+#include "../include/lib/string.h"
+#include "../include/location/location.h"
+#include "../include/location/position.h"
+#include "../include/parser/parser.h"
 #include "../include/visitor.h"
 
 #include <prism.h>
@@ -74,8 +75,7 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
 
     hb_string_T opening = erb_content_node->tag_opening->value;
 
-    if (!hb_string_equals(opening, hb_string("<%%")) && !hb_string_equals(opening, hb_string("<%%="))
-        && !hb_string_equals(opening, hb_string("<%#")) && !hb_string_equals(opening, hb_string("<%graphql"))) {
+    if (!hb_string_equals(opening, hb_string("<%#")) && !hb_string_equals(opening, hb_string("<%graphql"))) {
       analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
 
       erb_content_node->parsed = true;
@@ -252,6 +252,14 @@ static size_t process_begin_structure(
   analyze_ruby_context_T* context
 );
 
+static size_t process_block_structure(
+  AST_NODE_T* node,
+  hb_array_T* array,
+  size_t index,
+  hb_array_T* output_array,
+  analyze_ruby_context_T* context
+);
+
 static size_t process_generic_structure(
   AST_NODE_T* node,
   hb_array_T* array,
@@ -272,8 +280,8 @@ static size_t process_control_structure(
   switch (initial_type) {
     case CONTROL_TYPE_CASE:
     case CONTROL_TYPE_CASE_MATCH: return process_case_structure(node, array, index, output_array, context);
-
     case CONTROL_TYPE_BEGIN: return process_begin_structure(node, array, index, output_array, context);
+    case CONTROL_TYPE_BLOCK: return process_block_structure(node, array, index, output_array, context);
 
     default: return process_generic_structure(node, array, index, output_array, context, initial_type);
   }
@@ -630,6 +638,126 @@ static size_t process_begin_structure(
   return index;
 }
 
+static size_t process_block_structure(
+  AST_NODE_T* node,
+  hb_array_T* array,
+  size_t index,
+  hb_array_T* output_array,
+  analyze_ruby_context_T* context
+) {
+  hb_allocator_T* allocator = context->allocator;
+  AST_ERB_CONTENT_NODE_T* erb_node = get_erb_content_at(array, index);
+  if (!erb_node) { return index; }
+  hb_array_T* children = hb_array_init(8, allocator);
+
+  index++;
+  index = process_block_children(node, array, index, children, context, CONTROL_TYPE_BLOCK);
+
+  AST_ERB_RESCUE_NODE_T* rescue_clause = NULL;
+  AST_ERB_ELSE_NODE_T* else_clause = NULL;
+  AST_ERB_ENSURE_NODE_T* ensure_clause = NULL;
+
+  control_type_t next_type = CONTROL_TYPE_UNKNOWN;
+  AST_ERB_CONTENT_NODE_T* next_erb = NULL;
+
+  if (peek_control_type(array, index, &next_type, &next_erb) && next_type == CONTROL_TYPE_RESCUE) {
+    AST_NODE_T* rescue_node = NULL;
+    index = process_subsequent_block(node, array, index, &rescue_node, context, CONTROL_TYPE_BLOCK);
+    rescue_clause = (AST_ERB_RESCUE_NODE_T*) rescue_node;
+  }
+
+  if (peek_control_type(array, index, &next_type, &next_erb) && next_type == CONTROL_TYPE_ELSE) {
+    hb_array_T* else_children = hb_array_init(8, allocator);
+    index++;
+
+    index = process_block_children(node, array, index, else_children, context, CONTROL_TYPE_BLOCK);
+
+    hb_array_T* else_errors = next_erb->base.errors;
+    next_erb->base.errors = NULL;
+
+    else_clause = ast_erb_else_node_init(
+      next_erb->tag_opening,
+      next_erb->content,
+      next_erb->tag_closing,
+      else_children,
+      next_erb->tag_opening->location.start,
+      erb_content_end_position(next_erb),
+      else_errors,
+      allocator
+    );
+
+    ast_node_free((AST_NODE_T*) next_erb, allocator);
+  }
+
+  if (peek_control_type(array, index, &next_type, &next_erb) && next_type == CONTROL_TYPE_ENSURE) {
+    hb_array_T* ensure_children = hb_array_init(8, allocator);
+    index++;
+
+    const control_type_t ensure_stop[] = { CONTROL_TYPE_END, CONTROL_TYPE_BLOCK_CLOSE };
+    collect_children_until(array, &index, ensure_children, ensure_stop, sizeof(ensure_stop) / sizeof(ensure_stop[0]));
+
+    hb_array_T* ensure_errors = next_erb->base.errors;
+    next_erb->base.errors = NULL;
+
+    ensure_clause = ast_erb_ensure_node_init(
+      next_erb->tag_opening,
+      next_erb->content,
+      next_erb->tag_closing,
+      ensure_children,
+      next_erb->tag_opening->location.start,
+      erb_content_end_position(next_erb),
+      ensure_errors,
+      allocator
+    );
+
+    ast_node_free((AST_NODE_T*) next_erb, allocator);
+  }
+
+  const control_type_t end_types[] = { CONTROL_TYPE_BLOCK_CLOSE, CONTROL_TYPE_END };
+  AST_ERB_END_NODE_T* end_node =
+    consume_end_node(array, &index, end_types, sizeof(end_types) / sizeof(end_types[0]), allocator);
+
+  position_T start_position = erb_node->tag_opening->location.start;
+  position_T end_position = erb_content_end_position(erb_node);
+
+  if (end_node) {
+    end_position = end_node->base.location.end;
+  } else if (ensure_clause) {
+    end_position = ensure_clause->base.location.end;
+  } else if (else_clause) {
+    end_position = else_clause->base.location.end;
+  } else if (rescue_clause) {
+    end_position = rescue_clause->base.location.end;
+  } else if (hb_array_size(children) > 0) {
+    AST_NODE_T* last_child = hb_array_last(children);
+    end_position = last_child->location.end;
+  }
+
+  hb_array_T* block_errors = erb_node->base.errors;
+  erb_node->base.errors = NULL;
+
+  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,
+    rescue_clause,
+    else_clause,
+    ensure_clause,
+    end_node,
+    start_position,
+    end_position,
+    block_errors,
+    allocator
+  );
+
+  ast_node_free((AST_NODE_T*) erb_node, allocator);
+  hb_array_append(output_array, (AST_NODE_T*) block_node);
+
+  return index;
+}
+
 static size_t process_generic_structure(
   AST_NODE_T* node,
   hb_array_T* array,
@@ -796,6 +924,28 @@ static size_t process_block_children(
   return index;
 }
 
+hb_array_T* get_node_children_array(const AST_NODE_T* node) {
+  if (!node) { return NULL; }
+
+  switch (node->type) {
+    case AST_DOCUMENT_NODE: return ((AST_DOCUMENT_NODE_T*) node)->children;
+    case AST_HTML_ELEMENT_NODE: return ((AST_HTML_ELEMENT_NODE_T*) node)->body;
+    case AST_ERB_BLOCK_NODE: return ((AST_ERB_BLOCK_NODE_T*) node)->body;
+    case AST_ERB_IF_NODE: return ((AST_ERB_IF_NODE_T*) node)->statements;
+    case AST_ERB_UNLESS_NODE: return ((AST_ERB_UNLESS_NODE_T*) node)->statements;
+    case AST_ERB_ELSE_NODE: return ((AST_ERB_ELSE_NODE_T*) node)->statements;
+    case AST_ERB_WHILE_NODE: return ((AST_ERB_WHILE_NODE_T*) node)->statements;
+    case AST_ERB_UNTIL_NODE: return ((AST_ERB_UNTIL_NODE_T*) node)->statements;
+    case AST_ERB_FOR_NODE: return ((AST_ERB_FOR_NODE_T*) node)->statements;
+    case AST_ERB_BEGIN_NODE: return ((AST_ERB_BEGIN_NODE_T*) node)->statements;
+    case AST_ERB_RESCUE_NODE: return ((AST_ERB_RESCUE_NODE_T*) node)->statements;
+    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;
+    default: return NULL;
+  }
+}
+
 hb_array_T* rewrite_node_array(AST_NODE_T* node, hb_array_T* array, analyze_ruby_context_T* context) {
   hb_allocator_T* allocator = context->allocator;
   hb_array_T* new_array = hb_array_init(hb_array_size(array), allocator);
@@ -862,6 +1012,10 @@ void herb_analyze_parse_tree(
 
   if (options && options->render_nodes) { herb_visit_node((AST_NODE_T*) document, transform_render_nodes, &context); }
 
+  if (options && options->strict_locals) {
+    herb_visit_node((AST_NODE_T*) document, transform_strict_locals_nodes, &context);
+  }
+
   if (options && options->action_view_helpers) {
     herb_visit_node((AST_NODE_T*) document, transform_tag_helper_nodes, &context);
   }
@@ -877,7 +1031,7 @@ void herb_analyze_parse_tree(
 
   herb_visit_node((AST_NODE_T*) document, detect_invalid_erb_structures, &invalid_context);
 
-  herb_analyze_parse_errors(document, source, allocator);
+  herb_analyze_parse_errors(document, source, options, allocator);
 
   herb_parser_match_html_tags_post_analyze(document, options, allocator);
 

data/src/analyze/{helpers.c → analyze_helpers.c}

@@ -3,7 +3,7 @@
 #include <string.h>
 
 #include "../include/analyze/analyzed_ruby.h"
-#include "../include/util/string.h"
+#include "../include/lib/string.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed) {
   return analyzed && analyzed->if_node_count > 0;

data/src/analyze/analyzed_ruby.c

@@ -1,5 +1,5 @@
 #include "../include/analyze/analyzed_ruby.h"
-#include "../include/util/hb_string.h"
+#include "../include/lib/hb_string.h"
 
 #include <prism.h>
 #include <string.h>

data/src/analyze/builders.c

@@ -1,13 +1,13 @@
 #include "../include/analyze/builders.h"
 #include "../include/analyze/analyze.h"
-#include "../include/ast_nodes.h"
-#include "../include/location.h"
-#include "../include/position.h"
-#include "../include/prism_helpers.h"
-#include "../include/token_struct.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_array.h"
-#include "../include/util/hb_string.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/lexer/token_struct.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_string.h"
+#include "../include/location/location.h"
+#include "../include/location/position.h"
+#include "../include/prism/prism_helpers.h"
 
 #include <stddef.h>
 #include <string.h>
@@ -322,6 +322,9 @@ static AST_NODE_T* build_block_node(control_builder_context_T* context) {
     context->tag_closing,
     HERB_PRISM_NODE_EMPTY,
     context->children,
+    NULL,
+    NULL,
+    NULL,
     context->end_node,
     context->start_position,
     context->end_position,

data/src/analyze/conditional_elements.c

@@ -1,11 +1,10 @@
 #include "../include/analyze/conditional_elements.h"
-#include "../include/ast_nodes.h"
-#include "../include/element_source.h"
+#include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
-#include "../include/token_struct.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_array.h"
-#include "../include/util/hb_string.h"
+#include "../include/lexer/token_struct.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_string.h"
 #include "../include/visitor.h"
 
 #include <stdbool.h>
@@ -365,7 +364,7 @@ static void rewrite_conditional_elements(hb_array_T* nodes, hb_array_T* document
       (AST_NODE_T*) close_tag,
       node,
       matched_open->open_tag->tag_name,
-      ELEMENT_SOURCE_HTML,
+      hb_string("HTML"),
       start_position,
       end_position,
       errors,

data/src/analyze/conditional_open_tags.c

@@ -1,11 +1,10 @@
 #include "../include/analyze/conditional_open_tags.h"
-#include "../include/ast_nodes.h"
-#include "../include/element_source.h"
+#include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
-#include "../include/token_struct.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_array.h"
-#include "../include/util/hb_string.h"
+#include "../include/lexer/token_struct.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_string.h"
 #include "../include/visitor.h"
 
 #include <stdbool.h>
@@ -409,7 +408,7 @@ static void rewrite_conditional_open_tags(hb_array_T* nodes, hb_array_T* documen
       body,
       (AST_NODE_T*) close_tag,
       false,
-      ELEMENT_SOURCE_HTML,
+      hb_string("HTML"),
       start_position,
       end_position,
       element_errors,

data/src/analyze/control_type.c

@@ -2,7 +2,7 @@
 #include "../include/analyze/analyze.h"
 #include "../include/analyze/analyzed_ruby.h"
 #include "../include/analyze/helpers.h"
-#include "../include/ast_node.h"
+#include "../include/ast/ast_node.h"
 
 #include <prism.h>
 #include <stdbool.h>
@@ -213,6 +213,7 @@ bool is_subsequent_type(control_type_t parent_type, control_type_t child_type) {
     case CONTROL_TYPE_CASE:
     case CONTROL_TYPE_CASE_MATCH: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
     case CONTROL_TYPE_BEGIN:
+    case CONTROL_TYPE_BLOCK:
       return child_type == CONTROL_TYPE_RESCUE || child_type == CONTROL_TYPE_ELSE || child_type == CONTROL_TYPE_ENSURE;
     case CONTROL_TYPE_RESCUE: return child_type == CONTROL_TYPE_RESCUE;
     case CONTROL_TYPE_UNLESS: return child_type == CONTROL_TYPE_ELSE;
@@ -227,7 +228,8 @@ bool is_terminator_type(control_type_t parent_type, control_type_t child_type) {
   switch (parent_type) {
     case CONTROL_TYPE_WHEN: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
     case CONTROL_TYPE_IN: return child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE;
-    case CONTROL_TYPE_BLOCK: return child_type == CONTROL_TYPE_BLOCK_CLOSE;
+    case CONTROL_TYPE_BLOCK:
+      return child_type == CONTROL_TYPE_BLOCK_CLOSE || is_subsequent_type(parent_type, child_type);
 
     default: return is_subsequent_type(parent_type, child_type);
   }

data/src/analyze/invalid_structures.c

@@ -2,12 +2,12 @@
 #include "../include/analyze/analyze.h"
 #include "../include/analyze/analyzed_ruby.h"
 #include "../include/analyze/helpers.h"
-#include "../include/ast_node.h"
-#include "../include/ast_nodes.h"
+#include "../include/ast/ast_node.h"
+#include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
-#include "../include/token_struct.h"
-#include "../include/util/hb_array.h"
-#include "../include/util/hb_string.h"
+#include "../include/lexer/token_struct.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_string.h"
 #include "../include/visitor.h"
 
 #include <stdbool.h>

data/src/analyze/missing_end.c

@@ -3,8 +3,8 @@
 
 #include "../include/analyze/helpers.h"
 #include "../include/errors.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_string.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_string.h"
 
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator) {

data/src/analyze/parse_errors.c

@@ -1,16 +1,47 @@
 #include "../include/analyze/analyze.h"
-#include "../include/ast_node.h"
-#include "../include/ast_nodes.h"
+#include "../include/ast/ast_node.h"
+#include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
 #include "../include/extract.h"
-#include "../include/prism_helpers.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_string.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_string.h"
+#include "../include/prism/prism_helpers.h"
 
 #include <prism.h>
 #include <stdlib.h>
 #include <string.h>
 
+static bool document_has_anonymous_keyword_rest(AST_DOCUMENT_NODE_T* document) {
+  if (!document || !document->children) { return false; }
+
+  for (size_t index = 0; index < hb_array_size(document->children); index++) {
+    AST_NODE_T* child = hb_array_get(document->children, index);
+    if (!child || child->type != AST_ERB_STRICT_LOCALS_NODE) { continue; }
+
+    AST_ERB_STRICT_LOCALS_NODE_T* strict_locals_node = (AST_ERB_STRICT_LOCALS_NODE_T*) child;
+    if (!strict_locals_node->locals) { continue; }
+
+    for (size_t local_index = 0; local_index < hb_array_size(strict_locals_node->locals); local_index++) {
+      AST_RUBY_STRICT_LOCAL_NODE_T* local = hb_array_get(strict_locals_node->locals, local_index);
+      if (local && local->double_splat && local->name == NULL) { return true; }
+    }
+  }
+
+  return false;
+}
+
+static bool should_skip_forwarding_error(
+  const pm_diagnostic_t* error,
+  bool strict_locals_enabled,
+  bool has_anonymous_keyword_rest
+) {
+  if (error->diag_id != PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR) { return false; }
+
+  if (!strict_locals_enabled) { return true; }
+
+  return has_anonymous_keyword_rest;
+}
+
 static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source, hb_allocator_T* allocator) {
   if (!erb_node || erb_node->type != AST_ERB_CONTENT_NODE) { return; }
   AST_ERB_CONTENT_NODE_T* content_node = (AST_ERB_CONTENT_NODE_T*) erb_node;
@@ -45,11 +76,19 @@ static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source, h
   free(content);
 }
 
-void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source, hb_allocator_T* allocator) {
+void herb_analyze_parse_errors(
+  AST_DOCUMENT_NODE_T* document,
+  const char* source,
+  const parser_options_T* parser_options,
+  hb_allocator_T* allocator
+) {
   char* extracted_ruby = herb_extract_ruby_with_semicolons(source, allocator);
 
   if (!extracted_ruby) { return; }
 
+  bool strict_locals_enabled = parser_options && parser_options->strict_locals;
+  bool has_anonymous_keyword_rest = strict_locals_enabled && document_has_anonymous_keyword_rest(document);
+
   pm_parser_t parser;
   pm_options_t options = { 0, .partial_script = true };
   pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), &options);
@@ -58,6 +97,8 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
 
   for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head; error != NULL;
        error = (const pm_diagnostic_t*) error->node.next) {
+    if (should_skip_forwarding_error(error, strict_locals_enabled, has_anonymous_keyword_rest)) { continue; }
+
     size_t error_offset = (size_t) (error->location.start - parser.start);
 
     if (strstr(error->message, "unexpected ';'") != NULL) {

data/src/analyze/prism_annotate.c

@@ -1,12 +1,12 @@
 #include "../include/analyze/prism_annotate.h"
-#include "../include/ast_node.h"
-#include "../include/ast_nodes.h"
+#include "../include/ast/ast_node.h"
+#include "../include/ast/ast_nodes.h"
 #include "../include/extract.h"
-#include "../include/herb_prism_node.h"
-#include "../include/prism_context.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_buffer.h"
-#include "../include/util/hb_narray.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_buffer.h"
+#include "../include/lib/hb_narray.h"
+#include "../include/prism/herb_prism_node.h"
+#include "../include/prism/prism_context.h"
 #include "../include/visitor.h"
 
 #include <prism.h>

data/src/analyze/render_nodes.c

@@ -2,12 +2,12 @@
 #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/ast_nodes.h"
+#include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
-#include "../include/util/hb_allocator.h"
-#include "../include/util/hb_array.h"
-#include "../include/util/hb_string.h"
-#include "../include/util/string.h"
+#include "../include/lib/hb_allocator.h"
+#include "../include/lib/hb_array.h"
+#include "../include/lib/hb_string.h"
+#include "../include/lib/string.h"
 #include "../include/visitor.h"
 
 #include <prism.h>
@@ -727,27 +727,7 @@ static void transform_render_nodes_in_array(hb_array_T* array, analyze_ruby_cont
 static void transform_render_in_node(const AST_NODE_T* node, analyze_ruby_context_T* context) {
   if (!node || !context) { return; }
 
-  hb_array_T* array = NULL;
-
-  switch (node->type) {
-    case AST_DOCUMENT_NODE: array = ((AST_DOCUMENT_NODE_T*) node)->children; break;
-    case AST_HTML_ELEMENT_NODE: array = ((AST_HTML_ELEMENT_NODE_T*) node)->body; break;
-    case AST_ERB_BLOCK_NODE: array = ((AST_ERB_BLOCK_NODE_T*) node)->body; break;
-    case AST_ERB_IF_NODE: array = ((AST_ERB_IF_NODE_T*) node)->statements; break;
-    case AST_ERB_UNLESS_NODE: array = ((AST_ERB_UNLESS_NODE_T*) node)->statements; break;
-    case AST_ERB_ELSE_NODE: array = ((AST_ERB_ELSE_NODE_T*) node)->statements; break;
-    case AST_ERB_WHILE_NODE: array = ((AST_ERB_WHILE_NODE_T*) node)->statements; break;
-    case AST_ERB_UNTIL_NODE: array = ((AST_ERB_UNTIL_NODE_T*) node)->statements; break;
-    case AST_ERB_FOR_NODE: array = ((AST_ERB_FOR_NODE_T*) node)->statements; break;
-    case AST_ERB_BEGIN_NODE: array = ((AST_ERB_BEGIN_NODE_T*) node)->statements; break;
-    case AST_ERB_RESCUE_NODE: array = ((AST_ERB_RESCUE_NODE_T*) node)->statements; break;
-    case AST_ERB_ENSURE_NODE: array = ((AST_ERB_ENSURE_NODE_T*) node)->statements; break;
-    case AST_ERB_CASE_NODE: array = ((AST_ERB_CASE_NODE_T*) node)->children; break;
-    case AST_ERB_WHEN_NODE: array = ((AST_ERB_WHEN_NODE_T*) node)->statements; break;
-    default: return;
-  }
-
-  transform_render_nodes_in_array(array, context);
+  transform_render_nodes_in_array(get_node_children_array(node), context);
 }
 
 bool transform_render_nodes(const AST_NODE_T* node, void* data) {