herb 0.9.1-aarch64-linux-gnu → 0.9.3-aarch64-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>
@@ -252,6 +253,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 +281,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 +639,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 +925,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 +1013,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);
   }

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,11 +1,11 @@
 #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>

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) {