herb 0.10.3-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/src/analyze/builders.c

@@ -12,18 +12,37 @@
 #include <stddef.h>
 #include <string.h>
 
+position_T erb_tag_start_position(const token_T* tag_opening, const token_T* content, location_T location) {
+  if (tag_opening != NULL) { return tag_opening->location.start; }
+  if (content != NULL) { return content->location.start; }
+
+  return location.start;
+}
+
+position_T erb_tag_end_position(
+  const token_T* tag_closing,
+  const token_T* content,
+  const token_T* tag_opening,
+  location_T location
+) {
+  if (tag_closing != NULL) { return tag_closing->location.end; }
+  if (content != NULL) { return content->location.end; }
+  if (tag_opening != NULL) { return tag_opening->location.end; }
+
+  return location.end;
+}
+
+position_T erb_content_start_position(const AST_ERB_CONTENT_NODE_T* erb_node) {
+  return erb_tag_start_position(erb_node->tag_opening, erb_node->content, erb_node->base.location);
+}
+
 position_T erb_content_end_position(const AST_ERB_CONTENT_NODE_T* erb_node) {
-  if (erb_node->tag_closing != NULL) {
-    return erb_node->tag_closing->location.end;
-  } else if (erb_node->content != NULL) {
-    return erb_node->content->location.end;
-  } else {
-    return erb_node->tag_opening->location.end;
-  }
+  return erb_tag_end_position(erb_node->tag_closing, erb_node->content, erb_node->tag_opening, erb_node->base.location);
 }
 
-location_T* compute_then_keyword(
-  AST_ERB_CONTENT_NODE_T* erb_node,
+location_T* compute_then_keyword_for_content(
+  token_T* content,
+  analyzed_ruby_T* analyzed_ruby,
   control_type_t control_type,
   hb_allocator_T* allocator
 ) {
@@ -32,10 +51,9 @@ location_T* compute_then_keyword(
     return NULL;
   }
 
-  token_T* content = erb_node->content;
-  const char* source = (content && !hb_string_is_empty(content->value))
-                       ? hb_allocator_strndup(allocator, content->value.data, content->value.length)
-                       : NULL;
+  char* source = (content && !hb_string_is_empty(content->value))
+                 ? hb_allocator_strndup(allocator, content->value.data, content->value.length)
+                 : NULL;
   location_T* then_keyword = NULL;
 
   if (control_type == CONTROL_TYPE_WHEN || control_type == CONTROL_TYPE_IN) {
@@ -47,7 +65,7 @@ location_T* compute_then_keyword(
       then_keyword = get_then_keyword_location_elsif_wrapped(source, allocator);
     }
   } else {
-    then_keyword = get_then_keyword_location(erb_node->analyzed_ruby, source, allocator);
+    then_keyword = get_then_keyword_location(analyzed_ruby, source, allocator);
   }
 
   if (then_keyword != NULL && content != NULL) {
@@ -59,9 +77,19 @@ location_T* compute_then_keyword(
     then_keyword->end.column = content_start.column + then_keyword->end.column;
   }
 
+  hb_allocator_dealloc(allocator, source);
+
   return then_keyword;
 }
 
+location_T* compute_then_keyword(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  control_type_t control_type,
+  hb_allocator_T* allocator
+) {
+  return compute_then_keyword_for_content(erb_node->content, erb_node->analyzed_ruby, control_type, allocator);
+}
+
 typedef struct {
   AST_ERB_CONTENT_NODE_T* erb;
   hb_array_T* children;
@@ -132,7 +160,7 @@ AST_NODE_T* create_control_node(
                                         .content = erb_node->content,
                                         .tag_closing = erb_node->tag_closing,
                                         .then_keyword = compute_then_keyword(erb_node, control_type, allocator),
-                                        .start_position = erb_node->tag_opening->location.start,
+                                        .start_position = erb_content_start_position(erb_node),
                                         .end_position = erb_content_end_position(erb_node),
                                         .errors = erb_node->base.errors,
                                         .control_type = control_type,
@@ -158,9 +186,9 @@ AST_NODE_T* create_control_node(
 
 static AST_NODE_T* build_if_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_if_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     context->then_keyword,
     HERB_PRISM_NODE_EMPTY,
     context->children,
@@ -175,9 +203,9 @@ static AST_NODE_T* build_if_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_else_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_else_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     context->children,
     context->start_position,
     context->end_position,
@@ -188,9 +216,9 @@ static AST_NODE_T* build_else_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_when_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_when_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     context->then_keyword,
     context->children,
     context->start_position,
@@ -202,9 +230,9 @@ static AST_NODE_T* build_when_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_in_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_in_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     context->then_keyword,
     context->children,
     context->start_position,
@@ -222,9 +250,9 @@ static AST_NODE_T* build_rescue_node(control_builder_context_T* context) {
   }
 
   return (AST_NODE_T*) ast_erb_rescue_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     context->children,
     rescue_node,
     context->start_position,
@@ -236,9 +264,9 @@ static AST_NODE_T* build_rescue_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_ensure_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_ensure_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     context->children,
     context->start_position,
     context->end_position,
@@ -255,9 +283,9 @@ static AST_NODE_T* build_unless_node(control_builder_context_T* context) {
   }
 
   return (AST_NODE_T*) ast_erb_unless_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     context->then_keyword,
     HERB_PRISM_NODE_EMPTY,
     context->children,
@@ -272,9 +300,9 @@ static AST_NODE_T* build_unless_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_while_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_while_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     HERB_PRISM_NODE_EMPTY,
     context->children,
     context->end_node,
@@ -287,9 +315,9 @@ static AST_NODE_T* build_while_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_until_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_until_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     HERB_PRISM_NODE_EMPTY,
     context->children,
     context->end_node,
@@ -302,9 +330,9 @@ static AST_NODE_T* build_until_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_for_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_for_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     HERB_PRISM_NODE_EMPTY,
     context->children,
     context->end_node,
@@ -317,9 +345,9 @@ static AST_NODE_T* build_for_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_block_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_block_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     HERB_PRISM_NODE_EMPTY,
     context->children,
     hb_array_init(0, context->allocator),
@@ -336,9 +364,9 @@ static AST_NODE_T* build_block_node(control_builder_context_T* context) {
 
 static AST_NODE_T* build_yield_node(control_builder_context_T* context) {
   return (AST_NODE_T*) ast_erb_yield_node_init(
-    context->tag_opening,
-    context->content,
-    context->tag_closing,
+    token_copy(context->tag_opening, context->allocator),
+    token_copy(context->content, context->allocator),
+    token_copy(context->tag_closing, context->allocator),
     context->start_position,
     context->end_position,
     context->errors,

data/src/analyze/conditional_elements.c

@@ -12,7 +12,7 @@
 #include <string.h>
 
 typedef struct {
-  hb_array_T* document_errors;
+  hb_array_T** document_errors;
   hb_allocator_T* allocator;
 } conditional_elements_context_T;
 
@@ -181,9 +181,8 @@ typedef struct {
   bool is_if;
 } conditional_open_tag_T;
 
-static void rewrite_conditional_elements(hb_array_T* nodes, hb_array_T* document_errors, hb_allocator_T* allocator) {
+static void rewrite_conditional_elements(hb_array_T* nodes, hb_array_T** document_errors, hb_allocator_T* allocator) {
   if (!nodes || hb_array_size(nodes) == 0) { return; }
-  if (!document_errors) { return; }
 
   for (size_t open_index = 0; open_index < hb_array_size(nodes); open_index++) {
     AST_NODE_T* open_node = (AST_NODE_T*) hb_array_get(nodes, open_index);
@@ -234,7 +233,7 @@ static void rewrite_conditional_elements(hb_array_T* nodes, hb_array_T* document
           allocator
         );
 
-        hb_array_append(document_errors, multiple_tags_error);
+        hb_array_append_lazy(document_errors, multiple_tags_error, allocator);
         break;
       }
     }
@@ -338,7 +337,7 @@ static void rewrite_conditional_elements(hb_array_T* nodes, hb_array_T* document
           allocator
         );
 
-      hb_array_append(document_errors, mismatch_error);
+      hb_array_append_lazy(document_errors, mismatch_error, allocator);
       continue;
     }
 
@@ -354,7 +353,7 @@ static void rewrite_conditional_elements(hb_array_T* nodes, hb_array_T* document
 
     position_T start_position = matched_open->open_conditional->location.start;
     position_T end_position = node->location.end;
-    hb_array_T* errors = hb_array_init(0, allocator);
+    hb_array_T* errors = NULL;
 
     AST_HTML_CONDITIONAL_ELEMENT_NODE_T* conditional_element = ast_html_conditional_element_node_init(
       matched_open->condition,
@@ -363,7 +362,7 @@ static void rewrite_conditional_elements(hb_array_T* nodes, hb_array_T* document
       body,
       (AST_NODE_T*) close_tag,
       node,
-      matched_open->open_tag->tag_name,
+      token_copy(matched_open->open_tag->tag_name, allocator),
       hb_string("HTML"),
       start_position,
       end_position,
@@ -507,6 +506,12 @@ static bool transform_conditional_elements_visitor(const AST_NODE_T* node, void*
       return false;
     }
 
+    case AST_ERB_ITERATION_BLOCK_NODE: {
+      AST_ERB_ITERATION_BLOCK_NODE_T* iteration_block_node = (AST_ERB_ITERATION_BLOCK_NODE_T*) node;
+      transform_conditional_elements_in_array(iteration_block_node->body, context);
+      return false;
+    }
+
     case AST_ERB_WHILE_NODE: {
       AST_ERB_WHILE_NODE_T* while_node = (AST_ERB_WHILE_NODE_T*) node;
       transform_conditional_elements_in_array(while_node->statements, context);
@@ -588,6 +593,6 @@ static bool transform_conditional_elements_visitor(const AST_NODE_T* node, void*
 }
 
 void herb_transform_conditional_elements(AST_DOCUMENT_NODE_T* document, hb_allocator_T* allocator) {
-  conditional_elements_context_T context = { .document_errors = document->base.errors, .allocator = allocator };
+  conditional_elements_context_T context = { .document_errors = &document->base.errors, .allocator = allocator };
   herb_visit_node((AST_NODE_T*) document, transform_conditional_elements_visitor, &context);
 }

data/src/analyze/conditional_open_tags.c

@@ -264,9 +264,7 @@ static void add_multiple_tags_error_to_erb_node(
     allocator
   );
 
-  if (!erb_node->errors) { erb_node->errors = hb_array_init(0, allocator); }
-
-  hb_array_append(erb_node->errors, error);
+  hb_array_append_lazy(&erb_node->errors, error, allocator);
 }
 
 static void check_and_report_multiple_tags_in_if(AST_ERB_IF_NODE_T* if_node, hb_allocator_T* allocator) {
@@ -392,7 +390,7 @@ static void rewrite_conditional_open_tags(hb_array_T* nodes, hb_array_T* documen
 
     AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T* conditional_open_tag = ast_html_conditional_open_tag_node_init(
       conditional_node,
-      tag_name_token,
+      token_copy(tag_name_token, allocator),
       false,
       conditional_node->location.start,
       conditional_node->location.end,
@@ -404,7 +402,7 @@ static void rewrite_conditional_open_tags(hb_array_T* nodes, hb_array_T* documen
 
     AST_HTML_ELEMENT_NODE_T* element = ast_html_element_node_init(
       (AST_NODE_T*) conditional_open_tag,
-      tag_name_token,
+      token_copy(tag_name_token, allocator),
       body,
       (AST_NODE_T*) close_tag,
       false,
@@ -425,6 +423,8 @@ static void rewrite_conditional_open_tags(hb_array_T* nodes, hb_array_T* documen
         hb_array_append(consumed_indices, index);
       }
     }
+
+    i = close_index;
   }
 
   if (hb_array_size(consumed_indices) > 0) {
@@ -531,6 +531,12 @@ static bool transform_conditional_open_tags_visitor(const AST_NODE_T* node, void
       return false;
     }
 
+    case AST_ERB_ITERATION_BLOCK_NODE: {
+      AST_ERB_ITERATION_BLOCK_NODE_T* iteration_block_node = (AST_ERB_ITERATION_BLOCK_NODE_T*) node;
+      transform_conditional_open_tags_in_array(iteration_block_node->body, context);
+      return false;
+    }
+
     case AST_ERB_WHILE_NODE: {
       AST_ERB_WHILE_NODE_T* while_node = (AST_ERB_WHILE_NODE_T*) node;
       transform_conditional_open_tags_in_array(while_node->statements, context);

data/src/analyze/control_type.c

@@ -3,6 +3,8 @@
 #include "../include/analyze/analyzed_ruby.h"
 #include "../include/analyze/helpers.h"
 #include "../include/ast/ast_node.h"
+#include "../include/errors.h"
+#include "../include/lib/hb_array.h"
 
 #include <prism.h>
 #include <stdbool.h>
@@ -179,9 +181,22 @@ static control_type_t find_earliest_control_keyword(pm_node_t* root, const uint8
   return result.found ? result.type : CONTROL_TYPE_UNKNOWN;
 }
 
+static bool erb_content_is_unterminated(const AST_ERB_CONTENT_NODE_T* erb_node) {
+  if (erb_node->tag_closing != NULL) { return false; }
+  if (erb_node->base.errors == NULL) { return false; }
+
+  for (size_t index = 0; index < hb_array_size(erb_node->base.errors); index++) {
+    const ERROR_T* error = hb_array_get(erb_node->base.errors, index);
+
+    if (error && error->type == UNCLOSED_ERB_TAG_ERROR) { return true; }
+  }
+
+  return false;
+}
+
 control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (!erb_node || erb_node->base.type != AST_ERB_CONTENT_NODE) { return CONTROL_TYPE_UNKNOWN; }
-  if (erb_node->tag_closing == NULL) { return CONTROL_TYPE_UNKNOWN; }
+  if (erb_content_is_unterminated(erb_node)) { return CONTROL_TYPE_UNKNOWN; }
 
   analyzed_ruby_T* ruby = erb_node->analyzed_ruby;