herb 0.9.4-arm-linux-gnu → 0.9.5-arm-linux-gnu

data/src/analyze/analyze_helpers.c

@@ -2,8 +2,14 @@
 #include <stdbool.h>
 #include <string.h>
 
+#include "../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../include/analyze/action_view/tag_helpers.h"
 #include "../include/analyze/analyzed_ruby.h"
+#include "../include/analyze/helpers.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/lib/hb_array.h"
 #include "../include/lib/string.h"
+#include "../include/prism/prism_helpers.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed) {
   return analyzed && analyzed->if_node_count > 0;
@@ -526,3 +532,403 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
 
   return false;
 }
+
+static pm_block_node_t* find_first_block_node(pm_node_t* node) {
+  if (!node) { return NULL; }
+
+  if (node->type == PM_CALL_NODE) {
+    pm_call_node_t* call = (pm_call_node_t*) node;
+
+    if (call->block && call->block->type == PM_BLOCK_NODE) { return (pm_block_node_t*) call->block; }
+  }
+
+  if (node->type == PM_PROGRAM_NODE) {
+    pm_program_node_t* program = (pm_program_node_t*) node;
+
+    if (program->statements && program->statements->body.size > 0) {
+      return find_first_block_node(program->statements->body.nodes[0]);
+    }
+  }
+
+  if (node->type == PM_STATEMENTS_NODE) {
+    pm_statements_node_t* statements = (pm_statements_node_t*) node;
+
+    if (statements->body.size > 0) { return find_first_block_node(statements->body.nodes[0]); }
+  }
+
+  return NULL;
+}
+
+static position_T prism_to_source_position(
+  const uint8_t* prism_pointer,
+  const uint8_t* prism_source_start,
+  size_t source_base_offset,
+  const char* source
+) {
+  if (!source || !prism_source_start) { return (position_T) { .line = 1, .column = 0 }; }
+
+  size_t prism_offset = (size_t) (prism_pointer - prism_source_start);
+  return byte_offset_to_position(source, source_base_offset + prism_offset);
+}
+
+static token_T* create_parameter_name_token(
+  pm_location_t location,
+  const char* name,
+  const uint8_t* prism_source_start,
+  size_t source_base_offset,
+  const char* source,
+  hb_allocator_T* allocator
+) {
+  position_T start = prism_to_source_position(location.start, prism_source_start, source_base_offset, source);
+  position_T end = prism_to_source_position(location.end, prism_source_start, source_base_offset, source);
+
+  return create_synthetic_token(allocator, name, TOKEN_IDENTIFIER, start, end);
+}
+
+static void append_parameter(
+  hb_array_T* result,
+  token_T* name_token,
+  AST_RUBY_LITERAL_NODE_T* default_value,
+  const char* kind,
+  bool required,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+) {
+  hb_array_append(
+    result,
+    ast_ruby_parameter_node_init(
+      name_token,
+      default_value,
+      hb_string(kind),
+      required,
+      start,
+      end,
+      hb_array_init(0, allocator),
+      allocator
+    )
+  );
+}
+
+hb_array_T* extract_parameters_from_prism(
+  pm_parameters_node_t* parameters,
+  pm_parser_t* parser,
+  const char* source,
+  size_t source_base_offset,
+  const uint8_t* prism_source_start,
+  hb_allocator_T* allocator
+) {
+  if (!parameters) { return hb_array_init(0, allocator); }
+
+  size_t count = parameters->requireds.size + parameters->optionals.size + parameters->keywords.size;
+  if (parameters->rest) { count++; }
+  if (parameters->keyword_rest) { count++; }
+  if (parameters->block) { count++; }
+
+  hb_array_T* result = hb_array_init(count, allocator);
+
+  // Required positional: |item|
+  for (size_t index = 0; index < parameters->requireds.size; index++) {
+    pm_node_t* node = parameters->requireds.nodes[index];
+    if (node->type != PM_REQUIRED_PARAMETER_NODE) { continue; }
+
+    pm_required_parameter_node_t* required = (pm_required_parameter_node_t*) node;
+    pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, required->name);
+    if (!constant) { continue; }
+
+    char* name = hb_allocator_strndup(allocator, (const char*) constant->start, constant->length);
+    position_T start = prism_to_source_position(node->location.start, prism_source_start, source_base_offset, source);
+    position_T end = prism_to_source_position(node->location.end, prism_source_start, source_base_offset, source);
+
+    append_parameter(
+      result,
+      create_parameter_name_token(node->location, name, prism_source_start, source_base_offset, source, allocator),
+      NULL,
+      "positional",
+      true,
+      start,
+      end,
+      allocator
+    );
+
+    hb_allocator_dealloc(allocator, name);
+  }
+
+  // Optional positional: |item = nil|
+  for (size_t index = 0; index < parameters->optionals.size; index++) {
+    pm_node_t* node = parameters->optionals.nodes[index];
+    if (node->type != PM_OPTIONAL_PARAMETER_NODE) { continue; }
+
+    pm_optional_parameter_node_t* optional = (pm_optional_parameter_node_t*) node;
+    size_t name_length = (size_t) (optional->name_loc.end - optional->name_loc.start);
+    char* name = hb_allocator_strndup(allocator, (const char*) optional->name_loc.start, name_length);
+
+    position_T start = prism_to_source_position(node->location.start, prism_source_start, source_base_offset, source);
+    position_T end = prism_to_source_position(node->location.end, prism_source_start, source_base_offset, source);
+
+    AST_RUBY_LITERAL_NODE_T* default_value = NULL;
+
+    if (optional->value) {
+      size_t value_length = (size_t) (optional->value->location.end - optional->value->location.start);
+      char* value_string = hb_allocator_strndup(allocator, (const char*) optional->value->location.start, value_length);
+      position_T value_start =
+        prism_to_source_position(optional->value->location.start, prism_source_start, source_base_offset, source);
+      position_T value_end =
+        prism_to_source_position(optional->value->location.end, prism_source_start, source_base_offset, source);
+
+      default_value = ast_ruby_literal_node_init(
+        hb_string_from_c_string(value_string),
+        value_start,
+        value_end,
+        hb_array_init(0, allocator),
+        allocator
+      );
+      hb_allocator_dealloc(allocator, value_string);
+    }
+
+    append_parameter(
+      result,
+      create_parameter_name_token(optional->name_loc, name, prism_source_start, source_base_offset, source, allocator),
+      default_value,
+      "positional",
+      false,
+      start,
+      end,
+      allocator
+    );
+
+    hb_allocator_dealloc(allocator, name);
+  }
+
+  // Rest: |*items|
+  if (parameters->rest && parameters->rest->type == PM_REST_PARAMETER_NODE) {
+    pm_rest_parameter_node_t* rest = (pm_rest_parameter_node_t*) parameters->rest;
+
+    if (rest->name) {
+      size_t name_length = (size_t) (rest->name_loc.end - rest->name_loc.start);
+      char* name = hb_allocator_strndup(allocator, (const char*) rest->name_loc.start, name_length);
+
+      position_T start =
+        prism_to_source_position(parameters->rest->location.start, prism_source_start, source_base_offset, source);
+      position_T end =
+        prism_to_source_position(parameters->rest->location.end, prism_source_start, source_base_offset, source);
+
+      append_parameter(
+        result,
+        create_parameter_name_token(rest->name_loc, name, prism_source_start, source_base_offset, source, allocator),
+        NULL,
+        "rest",
+        false,
+        start,
+        end,
+        allocator
+      );
+
+      hb_allocator_dealloc(allocator, name);
+    }
+  }
+
+  // Keywords: |name:| or |title: "default"|
+  for (size_t index = 0; index < parameters->keywords.size; index++) {
+    pm_node_t* keyword = parameters->keywords.nodes[index];
+
+    pm_location_t name_location;
+    bool is_required = false;
+    AST_RUBY_LITERAL_NODE_T* default_value = NULL;
+
+    if (keyword->type == PM_REQUIRED_KEYWORD_PARAMETER_NODE) {
+      name_location = ((pm_required_keyword_parameter_node_t*) keyword)->name_loc;
+      is_required = true;
+    } else if (keyword->type == PM_OPTIONAL_KEYWORD_PARAMETER_NODE) {
+      pm_optional_keyword_parameter_node_t* optional_keyword = (pm_optional_keyword_parameter_node_t*) keyword;
+      name_location = optional_keyword->name_loc;
+
+      if (optional_keyword->value) {
+        size_t value_length =
+          (size_t) (optional_keyword->value->location.end - optional_keyword->value->location.start);
+        char* value_string =
+          hb_allocator_strndup(allocator, (const char*) optional_keyword->value->location.start, value_length);
+
+        position_T value_start = prism_to_source_position(
+          optional_keyword->value->location.start,
+          prism_source_start,
+          source_base_offset,
+          source
+        );
+
+        position_T value_end = prism_to_source_position(
+          optional_keyword->value->location.end,
+          prism_source_start,
+          source_base_offset,
+          source
+        );
+
+        default_value = ast_ruby_literal_node_init(
+          hb_string_from_c_string(value_string),
+          value_start,
+          value_end,
+          hb_array_init(0, allocator),
+          allocator
+        );
+
+        hb_allocator_dealloc(allocator, value_string);
+      }
+    } else {
+      continue;
+    }
+
+    size_t name_length = (size_t) (name_location.end - name_location.start);
+    if (name_length > 0 && name_location.start[name_length - 1] == ':') { name_length--; }
+    char* name = hb_allocator_strndup(allocator, (const char*) name_location.start, name_length);
+
+    position_T start =
+      prism_to_source_position(keyword->location.start, prism_source_start, source_base_offset, source);
+    position_T end = prism_to_source_position(keyword->location.end, prism_source_start, source_base_offset, source);
+
+    append_parameter(
+      result,
+      create_parameter_name_token(name_location, name, prism_source_start, source_base_offset, source, allocator),
+      default_value,
+      "keyword",
+      is_required,
+      start,
+      end,
+      allocator
+    );
+
+    hb_allocator_dealloc(allocator, name);
+  }
+
+  // Keyword rest: |**opts| or |**|
+  if (parameters->keyword_rest && parameters->keyword_rest->type == PM_KEYWORD_REST_PARAMETER_NODE) {
+    pm_keyword_rest_parameter_node_t* keyword_rest = (pm_keyword_rest_parameter_node_t*) parameters->keyword_rest;
+
+    position_T start = prism_to_source_position(
+      parameters->keyword_rest->location.start,
+      prism_source_start,
+      source_base_offset,
+      source
+    );
+
+    position_T end =
+      prism_to_source_position(parameters->keyword_rest->location.end, prism_source_start, source_base_offset, source);
+
+    if (keyword_rest->name) {
+      size_t name_length = (size_t) (keyword_rest->name_loc.end - keyword_rest->name_loc.start);
+      char* name = hb_allocator_strndup(allocator, (const char*) keyword_rest->name_loc.start, name_length);
+
+      append_parameter(
+        result,
+        create_parameter_name_token(
+          keyword_rest->name_loc,
+          name,
+          prism_source_start,
+          source_base_offset,
+          source,
+          allocator
+        ),
+        NULL,
+        "keyword_rest",
+        false,
+        start,
+        end,
+        allocator
+      );
+
+      hb_allocator_dealloc(allocator, name);
+    } else {
+      // Anonymous **
+      append_parameter(result, NULL, NULL, "keyword_rest", false, start, end, allocator);
+    }
+  }
+
+  // Block: |&blk|
+  if (parameters->block) {
+    pm_block_parameter_node_t* block_param = parameters->block;
+
+    if (block_param->name) {
+      size_t name_length = (size_t) (block_param->name_loc.end - block_param->name_loc.start);
+      char* name = hb_allocator_strndup(allocator, (const char*) block_param->name_loc.start, name_length);
+
+      position_T start =
+        prism_to_source_position(block_param->base.location.start, prism_source_start, source_base_offset, source);
+      position_T end =
+        prism_to_source_position(block_param->base.location.end, prism_source_start, source_base_offset, source);
+
+      append_parameter(
+        result,
+        create_parameter_name_token(
+          block_param->name_loc,
+          name,
+          prism_source_start,
+          source_base_offset,
+          source,
+          allocator
+        ),
+        NULL,
+        "block",
+        false,
+        start,
+        end,
+        allocator
+      );
+
+      hb_allocator_dealloc(allocator, name);
+    }
+  }
+
+  return result;
+}
+
+hb_array_T* extract_block_arguments_from_erb_node(
+  const AST_ERB_CONTENT_NODE_T* erb_node,
+  const char* source,
+  hb_array_T* errors,
+  hb_allocator_T* allocator
+) {
+  if (!erb_node || !erb_node->analyzed_ruby || !erb_node->analyzed_ruby->parsed) { return hb_array_init(0, allocator); }
+
+  pm_parser_t* parser = &erb_node->analyzed_ruby->parser;
+  pm_block_node_t* block_node = find_first_block_node(erb_node->analyzed_ruby->root);
+
+  if (!block_node || !block_node->parameters) { return hb_array_init(0, allocator); }
+  if (block_node->parameters->type != PM_BLOCK_PARAMETERS_NODE) { return hb_array_init(0, allocator); }
+
+  pm_block_parameters_node_t* block_parameters = (pm_block_parameters_node_t*) block_node->parameters;
+  size_t erb_content_offset = 0;
+
+  if (source && erb_node->content) {
+    erb_content_offset = calculate_byte_offset_from_position(source, erb_node->content->location.start);
+  }
+
+  const uint8_t* prism_source_start = (const uint8_t*) parser->start;
+
+  if (errors) {
+    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 (error->diag_id == PM_ERR_BLOCK_TERM_END) { continue; }
+      if (error->diag_id == PM_ERR_BLOCK_TERM_BRACE) { continue; }
+      if (error->diag_id == PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT) { continue; }
+
+      size_t error_start_offset = (size_t) (error->location.start - prism_source_start);
+      size_t error_end_offset = (size_t) (error->location.end - prism_source_start);
+
+      position_T error_start = byte_offset_to_position(source, erb_content_offset + error_start_offset);
+      position_T error_end = byte_offset_to_position(source, erb_content_offset + error_end_offset);
+
+      RUBY_PARSE_ERROR_T* parse_error =
+        ruby_parse_error_from_prism_error_with_positions(error, error_start, error_end, allocator);
+
+      hb_array_append(errors, parse_error);
+    }
+  }
+
+  return extract_parameters_from_prism(
+    block_parameters->parameters,
+    parser,
+    source,
+    erb_content_offset,
+    prism_source_start,
+    allocator
+  );
+}

data/src/analyze/builders.c

@@ -322,6 +322,7 @@ static AST_NODE_T* build_block_node(control_builder_context_T* context) {
     context->tag_closing,
     HERB_PRISM_NODE_EMPTY,
     context->children,
+    hb_array_init(0, context->allocator),
     NULL,
     NULL,
     NULL,

data/src/analyze/missing_end.c

@@ -153,6 +153,22 @@ void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allo
       break;
     }
 
+    case AST_ERB_RENDER_NODE: {
+      const AST_ERB_RENDER_NODE_T* erb_render_node = (const AST_ERB_RENDER_NODE_T*) node;
+
+      if (erb_render_node->end_node == NULL) {
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " render " "%" ">`"),
+          erb_render_node->tag_opening->location.start,
+          erb_render_node->tag_closing->location.end,
+          allocator,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
     default: break;
   }
 }

data/src/analyze/parse_errors.c

@@ -5,6 +5,7 @@
 #include "../include/extract.h"
 #include "../include/lib/hb_allocator.h"
 #include "../include/lib/hb_string.h"
+#include "../include/lib/string.h"
 #include "../include/prism/prism_helpers.h"
 
 #include <prism.h>
@@ -22,8 +23,8 @@ static bool document_has_anonymous_keyword_rest(AST_DOCUMENT_NODE_T* document) {
     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; }
+      AST_RUBY_PARAMETER_NODE_T* local = hb_array_get(strict_locals_node->locals, local_index);
+      if (local && string_equals(local->kind.data, "keyword_rest") && local->name == NULL) { return true; }
     }
   }