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

data/src/analyze/strict_locals.c

@@ -23,13 +23,10 @@
 #define SYNTHETIC_PREFIX "def _"
 #define SYNTHETIC_SUFFIX "; end"
 
-static bool is_strict_locals_node(const AST_ERB_CONTENT_NODE_T* node) {
+static bool is_strict_locals_node(const AST_ERB_COMMENT_NODE_T* node) {
   if (!node->tag_opening || !node->content) { return false; }
   if (hb_string_is_empty(node->tag_opening->value)) { return false; }
 
-  const char* opening = node->tag_opening->value.data;
-  if (!opening || !strstr(opening, "#")) { return false; }
-
   const char* content = node->content->value.data;
   if (!content) { return false; }
 
@@ -112,7 +109,8 @@ static hb_array_T* extract_strict_locals(
   const char* params_open,
   const uint8_t* synthetic_start,
   hb_array_T* errors,
-  hb_allocator_T* allocator
+  hb_allocator_T* allocator,
+  const parser_options_T* parser_options
 ) {
   if (!params) { return hb_array_init(0, allocator); }
 
@@ -132,11 +130,11 @@ static hb_array_T* extract_strict_locals(
     hb_string_T name = local->name ? local->name->value : hb_string("");
 
     if (string_equals(local->kind.data, "positional")) {
-      append_strict_locals_positional_argument_error(name, start, end, allocator, local->base.errors);
+      append_strict_locals_positional_argument_error(name, start, end, allocator, &local->base.errors, parser_options);
     } else if (string_equals(local->kind.data, "rest")) {
-      append_strict_locals_splat_argument_error(name, start, end, allocator, local->base.errors);
+      append_strict_locals_splat_argument_error(name, start, end, allocator, &local->base.errors, parser_options);
     } else if (string_equals(local->kind.data, "block")) {
-      append_strict_locals_block_argument_error(name, start, end, allocator, local->base.errors);
+      append_strict_locals_block_argument_error(name, start, end, allocator, &local->base.errors, parser_options);
     }
   }
 
@@ -144,9 +142,10 @@ static hb_array_T* extract_strict_locals(
 }
 
 static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
-  AST_ERB_CONTENT_NODE_T* erb_node,
+  AST_ERB_COMMENT_NODE_T* erb_node,
   const char* source,
-  hb_allocator_T* allocator
+  hb_allocator_T* allocator,
+  const parser_options_T* parser_options
 ) {
   const char* content_bytes = erb_node->content->value.data;
   const char* params_open = find_params_open(content_bytes);
@@ -183,16 +182,17 @@ static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
       error_start,
       error_end,
       allocator,
-      errors
+      &errors,
+      parser_options
     );
     hb_allocator_dealloc(allocator, rest);
 
     return ast_erb_strict_locals_node_init(
-      erb_node->tag_opening,
-      erb_node->content,
-      erb_node->tag_closing,
-      erb_node->analyzed_ruby,
-      erb_node->prism_node,
+      token_copy(erb_node->tag_opening, allocator),
+      token_copy(erb_node->content, allocator),
+      token_copy(erb_node->tag_closing, allocator),
+      NULL,
+      HERB_PRISM_NODE_EMPTY,
       locals,
       erb_node->base.location.start,
       erb_node->base.location.end,
@@ -265,7 +265,8 @@ static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
       params_open,
       synthetic_start,
       errors,
-      allocator
+      allocator,
+      parser_options
     );
   }
 
@@ -275,11 +276,11 @@ static AST_ERB_STRICT_LOCALS_NODE_T* create_strict_locals_node(
   hb_buffer_free(&synthetic_buffer);
 
   return ast_erb_strict_locals_node_init(
-    erb_node->tag_opening,
-    erb_node->content,
-    erb_node->tag_closing,
-    erb_node->analyzed_ruby,
-    erb_node->prism_node,
+    token_copy(erb_node->tag_opening, allocator),
+    token_copy(erb_node->content, allocator),
+    token_copy(erb_node->tag_closing, allocator),
+    NULL,
+    HERB_PRISM_NODE_EMPTY,
     locals,
     erb_node->base.location.start,
     erb_node->base.location.end,
@@ -293,14 +294,14 @@ static void transform_strict_locals_in_array(hb_array_T* array, analyze_ruby_con
 
   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; }
+    if (!child || child->type != AST_ERB_COMMENT_NODE) { continue; }
 
-    AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) child;
+    AST_ERB_COMMENT_NODE_T* erb_node = (AST_ERB_COMMENT_NODE_T*) child;
 
     if (!is_strict_locals_node(erb_node)) { continue; }
 
     AST_ERB_STRICT_LOCALS_NODE_T* strict_locals_node =
-      create_strict_locals_node(erb_node, context->source, context->allocator);
+      create_strict_locals_node(erb_node, context->source, context->allocator, context->options);
 
     if (!strict_locals_node) { continue; }
 
@@ -309,12 +310,15 @@ static void transform_strict_locals_in_array(hb_array_T* array, analyze_ruby_con
         strict_locals_node->base.location.start,
         strict_locals_node->base.location.end,
         context->allocator,
-        strict_locals_node->base.errors
+        &strict_locals_node->base.errors,
+        context->options
       );
     }
 
     context->found_strict_locals = true;
     hb_array_set(array, index, strict_locals_node);
+
+    ast_node_free(child, context->allocator);
   }
 }
 

data/src/analyze/ternary_conditionals.c

@@ -2,6 +2,7 @@
 #include "../include/analyze/action_view/tag_helper_node_builders.h"
 #include "../include/analyze/analyze.h"
 #include "../include/analyze/analyzed_ruby.h"
+#include "../include/analyze/helpers.h"
 #include "../include/ast/ast_nodes.h"
 #include "../include/lib/hb_allocator.h"
 #include "../include/lib/hb_array.h"
@@ -13,14 +14,6 @@
 #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_ternary_statement(analyzed_ruby_T* analyzed) {
   if (!analyzed || !analyzed->valid || !analyzed->root) { return NULL; }
 
@@ -72,7 +65,20 @@ static body_info_T extract_statements_body_info(
 
   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);
+
+  bool has_leading_space = info.length > 0 && *body_start == ' ';
+  bool has_trailing_space = info.length > 0 && *(body_end - 1) == ' ';
+
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, info.length + 2, allocator);
+
+  if (!has_leading_space) { hb_buffer_append_char(&buffer, ' '); }
+
+  hb_buffer_append_with_length(&buffer, (const char*) body_start, info.length);
+
+  if (!has_trailing_space) { hb_buffer_append_char(&buffer, ' '); }
+
+  info.source = hb_buffer_value(&buffer);
 
   return info;
 }
@@ -87,84 +93,85 @@ static char* extract_condition_source(pm_if_node_t* if_node, hb_allocator_T* all
   return hb_allocator_strndup(allocator, (const char*) predicate->location.start, length);
 }
 
-AST_NODE_T* transform_ternary_expression(
+static bool append_branch_statement(
+  hb_array_T* statements,
+  pm_statements_node_t* branch,
   AST_ERB_CONTENT_NODE_T* erb_node,
-  pm_if_node_t* if_node,
+  static_output_node_type_T static_node_type,
   hb_allocator_T* allocator
 ) {
-  body_info_T true_info = extract_statements_body_info(if_node->statements, erb_node->analyzed_ruby, allocator);
-  if (!true_info.source) { return NULL; }
-
-  pm_else_node_t* else_node = (pm_else_node_t*) if_node->subsequent;
-  if (!else_node) { return NULL; }
+  position_T content_start = erb_node->content->location.start;
 
-  body_info_T false_info = extract_statements_body_info(else_node->statements, erb_node->analyzed_ruby, allocator);
-  if (!false_info.source) { return NULL; }
+  if (append_static_output_node(
+        statements,
+        branch,
+        erb_node->analyzed_ruby,
+        content_start,
+        static_node_type,
+        allocator
+      )) {
+    return true;
+  }
 
-  char* condition_source = extract_condition_source(if_node, allocator);
-  if (!condition_source) { return NULL; }
+  body_info_T info = extract_statements_body_info(branch, erb_node->analyzed_ruby, allocator);
+  if (!info.source) { return false; }
 
-  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 branch_start = { .line = content_start.line,
+                              .column = content_start.column + (uint32_t) info.offset_in_content };
 
-  position_T true_content_start = { .line = content_start.line,
-                                    .column = content_start.column + (uint32_t) true_info.offset_in_content };
+  position_T branch_end = { .line = content_start.line,
+                            .column = content_start.column + (uint32_t) (info.offset_in_content + info.length) };
 
-  position_T true_content_end = { .line = content_start.line,
-                                  .column = content_start.column
-                                          + (uint32_t) (true_info.offset_in_content + true_info.length) };
+  token_T* content = create_synthetic_token(allocator, info.source, TOKEN_ERB_CONTENT, branch_start, branch_end);
 
-  token_T* true_content =
-    create_synthetic_token(allocator, true_info.source, TOKEN_ERB_CONTENT, true_content_start, true_content_end);
+  hb_allocator_dealloc(allocator, (void*) info.source);
 
-  AST_ERB_CONTENT_NODE_T* true_erb_node = ast_erb_content_node_init(
-    erb_node->tag_opening,
-    true_content,
-    erb_node->tag_closing,
+  AST_ERB_CONTENT_NODE_T* branch_erb_node = ast_erb_content_node_init(
+    token_copy(erb_node->tag_opening, allocator),
+    content,
+    token_copy(erb_node->tag_closing, allocator),
     NULL,
     false,
     true,
     HERB_PRISM_NODE_EMPTY,
-    start,
-    end,
+    erb_node->base.location.start,
+    erb_node->base.location.end,
     hb_array_init(0, allocator),
     allocator
   );
 
-  if (!true_erb_node) { return NULL; }
+  if (!branch_erb_node) { return false; }
 
-  position_T false_content_start = { .line = content_start.line,
-                                     .column = content_start.column + (uint32_t) false_info.offset_in_content };
+  hb_array_append(statements, (AST_NODE_T*) branch_erb_node);
 
-  position_T false_content_end = { .line = content_start.line,
-                                   .column = content_start.column
-                                           + (uint32_t) (false_info.offset_in_content + false_info.length) };
+  return true;
+}
 
-  token_T* false_content =
-    create_synthetic_token(allocator, false_info.source, TOKEN_ERB_CONTENT, false_content_start, false_content_end);
+AST_NODE_T* transform_ternary_expression(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  pm_if_node_t* if_node,
+  static_output_node_type_T static_node_type,
+  hb_allocator_T* allocator
+) {
+  pm_else_node_t* else_node = (pm_else_node_t*) if_node->subsequent;
+  if (!else_node) { return NULL; }
 
-  AST_ERB_CONTENT_NODE_T* false_erb_node = ast_erb_content_node_init(
-    erb_node->tag_opening,
-    false_content,
-    erb_node->tag_closing,
-    NULL,
-    false,
-    true,
-    HERB_PRISM_NODE_EMPTY,
-    start,
-    end,
-    hb_array_init(0, allocator),
-    allocator
-  );
+  char* condition_source = extract_condition_source(if_node, allocator);
+  if (!condition_source) { return NULL; }
 
-  if (!false_erb_node) { return NULL; }
+  position_T start = erb_node->base.location.start;
+  position_T end = erb_node->base.location.end;
 
   hb_array_T* true_statements = hb_array_init(1, allocator);
   hb_array_T* false_statements = hb_array_init(1, allocator);
 
-  hb_array_append(true_statements, (AST_NODE_T*) true_erb_node);
-  hb_array_append(false_statements, (AST_NODE_T*) false_erb_node);
+  if (!append_branch_statement(true_statements, if_node->statements, erb_node, static_node_type, allocator)) {
+    return NULL;
+  }
+
+  if (!append_branch_statement(false_statements, else_node->statements, erb_node, static_node_type, allocator)) {
+    return NULL;
+  }
 
   token_T* else_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, end, end);
   token_T* else_content_token = create_synthetic_token(allocator, " else ", TOKEN_ERB_CONTENT, end, end);
@@ -191,6 +198,9 @@ AST_NODE_T* transform_ternary_expression(
 
   token_T* if_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, start, start);
   token_T* if_content = create_synthetic_token(allocator, condition_content, TOKEN_ERB_CONTENT, start, end);
+
+  hb_buffer_free(&condition_buffer);
+  hb_allocator_dealloc(allocator, condition_source);
   token_T* if_closing = create_synthetic_token(allocator, "%>", TOKEN_ERB_END, end, end);
 
   token_T* end_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, end, end);
@@ -202,7 +212,7 @@ AST_NODE_T* transform_ternary_expression(
 
   herb_prism_node_T empty_prism_node = HERB_PRISM_NODE_EMPTY;
 
-  AST_ERB_IF_NODE_T* result_if_node = ast_erb_if_node_init(
+  return (AST_NODE_T*) ast_erb_if_node_init(
     if_opening,
     if_content,
     if_closing,
@@ -216,11 +226,13 @@ AST_NODE_T* transform_ternary_expression(
     hb_array_init(0, allocator),
     allocator
   );
-
-  return (AST_NODE_T*) result_if_node;
 }
 
-static void transform_ternary_array(hb_array_T* array, analyze_ruby_context_T* context) {
+static void transform_ternary_array(
+  hb_array_T* array,
+  analyze_ruby_context_T* context,
+  static_output_node_type_T static_node_type
+) {
   if (!array || !context) { return; }
 
   for (size_t i = 0; i < hb_array_size(array); i++) {
@@ -235,8 +247,12 @@ static void transform_ternary_array(hb_array_T* array, analyze_ruby_context_T* c
     pm_node_t* ternary_node = find_ternary_statement(erb_node->analyzed_ruby);
     if (!ternary_node) { continue; }
 
-    AST_NODE_T* replacement = transform_ternary_expression(erb_node, (pm_if_node_t*) ternary_node, context->allocator);
-    if (replacement) { hb_array_set(array, i, replacement); }
+    AST_NODE_T* replacement =
+      transform_ternary_expression(erb_node, (pm_if_node_t*) ternary_node, static_node_type, context->allocator);
+    if (replacement) {
+      hb_array_set(array, i, replacement);
+      ast_node_free(child, context->allocator);
+    }
   }
 }
 
@@ -244,11 +260,20 @@ static void transform_ternary_blocks(const AST_NODE_T* node, analyze_ruby_contex
   if (!node || !context) { return; }
 
   switch (node->type) {
-    case AST_DOCUMENT_NODE: transform_ternary_array(((AST_DOCUMENT_NODE_T*) node)->children, context); break;
-    case AST_HTML_ELEMENT_NODE: transform_ternary_array(((AST_HTML_ELEMENT_NODE_T*) node)->body, context); break;
-    case AST_HTML_OPEN_TAG_NODE: transform_ternary_array(((AST_HTML_OPEN_TAG_NODE_T*) node)->children, context); break;
+    case AST_DOCUMENT_NODE:
+      transform_ternary_array(((AST_DOCUMENT_NODE_T*) node)->children, context, STATIC_OUTPUT_NODE_HTML_TEXT);
+      break;
+
+    case AST_HTML_ELEMENT_NODE:
+      transform_ternary_array(((AST_HTML_ELEMENT_NODE_T*) node)->body, context, STATIC_OUTPUT_NODE_HTML_TEXT);
+      break;
+
+    case AST_HTML_OPEN_TAG_NODE:
+      transform_ternary_array(((AST_HTML_OPEN_TAG_NODE_T*) node)->children, context, STATIC_OUTPUT_NODE_NONE);
+      break;
+
     case AST_HTML_ATTRIBUTE_VALUE_NODE:
-      transform_ternary_array(((AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node)->children, context);
+      transform_ternary_array(((AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node)->children, context, STATIC_OUTPUT_NODE_LITERAL);
       break;
     default: break;
   }

data/src/analyze/transform.c

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /home/runner/work/herb/herb/templates/src/analyze/transform.c.erb
+// be modified manually. See templates/src/analyze/transform.c.erb
 
 #include "../include/analyze/analyze.h"
 #include "../include/visitor.h"
@@ -85,6 +85,13 @@ bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
     hb_array_free(&old_array);
   }
 
+  if (node->type == AST_XML_PROCESSING_INSTRUCTION_NODE) {
+    AST_XML_PROCESSING_INSTRUCTION_NODE_T* xml_processing_instruction_node = (AST_XML_PROCESSING_INSTRUCTION_NODE_T*) node;
+    hb_array_T* old_array = xml_processing_instruction_node->children;
+    xml_processing_instruction_node->children = rewrite_node_array((AST_NODE_T*) node, xml_processing_instruction_node->children, context);
+    hb_array_free(&old_array);
+  }
+
   if (node->type == AST_CDATA_NODE) {
     AST_CDATA_NODE_T* cdata_node = (AST_CDATA_NODE_T*) node;
     hb_array_T* old_array = cdata_node->children;
@@ -120,6 +127,27 @@ bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
     hb_array_free(&old_array);
   }
 
+  if (node->type == AST_ERB_ITERATION_BLOCK_NODE) {
+    AST_ERB_ITERATION_BLOCK_NODE_T* erb_iteration_block_node = (AST_ERB_ITERATION_BLOCK_NODE_T*) node;
+    hb_array_T* old_array = erb_iteration_block_node->arguments;
+    erb_iteration_block_node->arguments = rewrite_node_array((AST_NODE_T*) node, erb_iteration_block_node->arguments, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_ITERATION_BLOCK_NODE) {
+    AST_ERB_ITERATION_BLOCK_NODE_T* erb_iteration_block_node = (AST_ERB_ITERATION_BLOCK_NODE_T*) node;
+    hb_array_T* old_array = erb_iteration_block_node->body;
+    erb_iteration_block_node->body = rewrite_node_array((AST_NODE_T*) node, erb_iteration_block_node->body, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_ITERATION_BLOCK_NODE) {
+    AST_ERB_ITERATION_BLOCK_NODE_T* erb_iteration_block_node = (AST_ERB_ITERATION_BLOCK_NODE_T*) node;
+    hb_array_T* old_array = erb_iteration_block_node->block_arguments;
+    erb_iteration_block_node->block_arguments = rewrite_node_array((AST_NODE_T*) node, erb_iteration_block_node->block_arguments, context);
+    hb_array_free(&old_array);
+  }
+
   if (node->type == AST_ERB_WHEN_NODE) {
     AST_ERB_WHEN_NODE_T* erb_when_node = (AST_ERB_WHEN_NODE_T*) node;
     hb_array_T* old_array = erb_when_node->statements;
@@ -211,6 +239,13 @@ bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
     hb_array_free(&old_array);
   }
 
+  if (node->type == AST_RUBY_RENDER_KEYWORDS_NODE) {
+    AST_RUBY_RENDER_KEYWORDS_NODE_T* ruby_render_keywords_node = (AST_RUBY_RENDER_KEYWORDS_NODE_T*) node;
+    hb_array_T* old_array = ruby_render_keywords_node->state;
+    ruby_render_keywords_node->state = rewrite_node_array((AST_NODE_T*) node, ruby_render_keywords_node->state, context);
+    hb_array_free(&old_array);
+  }
+
   if (node->type == AST_ERB_RENDER_NODE) {
     AST_ERB_RENDER_NODE_T* erb_render_node = (AST_ERB_RENDER_NODE_T*) node;
     hb_array_T* old_array = erb_render_node->body;
@@ -239,6 +274,13 @@ bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
     hb_array_free(&old_array);
   }
 
+  if (node->type == AST_HERB_STATE_DIRECTIVE_NODE) {
+    AST_HERB_STATE_DIRECTIVE_NODE_T* herb_state_directive_node = (AST_HERB_STATE_DIRECTIVE_NODE_T*) node;
+    hb_array_T* old_array = herb_state_directive_node->states;
+    herb_state_directive_node->states = rewrite_node_array((AST_NODE_T*) node, herb_state_directive_node->states, context);
+    hb_array_free(&old_array);
+  }
+
   herb_visit_child_nodes(node, transform_erb_nodes, data);
 
   return false;

data/src/ast/ast_node.c

@@ -29,8 +29,10 @@ void ast_node_init(
   node->location.start = start;
   node->location.end = end;
 
+  (void) allocator;
+
   if (errors == NULL) {
-    node->errors = hb_array_init(0, allocator);
+    node->errors = NULL;
   } else {
     node->errors = errors;
   }
@@ -52,18 +54,6 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node) {
   return node->type;
 }
 
-size_t ast_node_errors_count(const AST_NODE_T* node) {
-  return hb_array_size(node->errors);
-}
-
-hb_array_T* ast_node_errors(const AST_NODE_T* node) {
-  return node->errors;
-}
-
-void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error) {
-  hb_array_append(node->errors, error);
-}
-
 void ast_node_set_start(AST_NODE_T* node, position_T position) {
   node->location.start = position;
 }