herb 0.10.4-x86_64-linux-gnu → 0.11.1-x86_64-linux-gnu

data/src/analyze/analyze_helpers.c

@@ -7,6 +7,7 @@
 #include "../include/analyze/analyzed_ruby.h"
 #include "../include/analyze/helpers.h"
 #include "../include/ast/ast_nodes.h"
+#include "../include/lexer/token.h"
 #include "../include/lib/hb_array.h"
 #include "../include/lib/string.h"
 #include "../include/prism/prism_helpers.h"
@@ -92,327 +93,313 @@ bool has_inline_case_condition(analyzed_ruby_T* analyzed) {
       || (has_case_match_node(analyzed) && has_in_node(analyzed));
 }
 
-bool has_error_message(analyzed_ruby_T* analyzed, const char* message) {
-  for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) analyzed->parser.error_list.head; error != NULL;
-       error = (const pm_diagnostic_t*) error->node.next) {
-    if (string_equals(error->message, message)) { return true; }
-  }
+typedef struct {
+  const uint8_t* source_start;
+  uint32_t offset;
+  bool found;
+} inline_condition_offset_T;
 
-  return false;
-}
-
-bool search_if_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+static bool search_inline_condition_offset(const pm_node_t* node, void* data) {
+  inline_condition_offset_T* context = (inline_condition_offset_T*) data;
 
-  if (node->type == PM_IF_NODE) {
-    const pm_if_node_t* if_node = (const pm_if_node_t*) node;
+  uint32_t keyword_offset = UINT32_MAX;
 
-    bool has_if_keyword = if_node->if_keyword_loc.start != NULL && if_node->if_keyword_loc.end != NULL;
-    bool has_end_keyword = if_node->end_keyword_loc.start != NULL && if_node->end_keyword_loc.end != NULL;
-
-    if (has_if_keyword && has_end_keyword) { analyzed->if_node_count++; }
+  if (node->type == PM_WHEN_NODE) {
+    keyword_offset = (uint32_t) (((const pm_when_node_t*) node)->keyword_loc.start - context->source_start);
+  } else if (node->type == PM_IN_NODE) {
+    keyword_offset = (uint32_t) (((const pm_in_node_t*) node)->in_loc.start - context->source_start);
+  } else if (node->type == PM_MATCH_PREDICATE_NODE) {
+    keyword_offset = (uint32_t) (((const pm_match_predicate_node_t*) node)->operator_loc.start - context->source_start);
   }
 
-  pm_visit_child_nodes(node, search_if_nodes, analyzed);
-
-  return false;
-}
-
-bool is_do_block(pm_location_t opening_location) {
-  size_t length = opening_location.end - opening_location.start;
-
-  return length == 2 && opening_location.start[0] == 'd' && opening_location.start[1] == 'o';
-}
-
-bool is_brace_block(pm_location_t opening_location) {
-  size_t length = opening_location.end - opening_location.start;
-
-  return length == 1 && opening_location.start[0] == '{';
-}
-
-static bool has_location(pm_location_t location) {
-  return location.start != NULL && location.end != NULL && (location.end - location.start) > 0;
-}
-
-static bool is_end_keyword(pm_location_t location) {
-  if (location.start == NULL || location.end == NULL) { return false; }
-
-  size_t length = location.end - location.start;
-
-  return length == 3 && location.start[0] == 'e' && location.start[1] == 'n' && location.start[2] == 'd';
-}
-
-bool is_closing_brace(pm_location_t location) {
-  if (location.start == NULL || location.end == NULL) { return false; }
-
-  size_t length = location.end - location.start;
-
-  return length == 1 && location.start[0] == '}';
-}
-
-bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc) {
-  if (is_do_block(opening_loc)) {
-    return is_end_keyword(closing_loc);
-  } else if (is_brace_block(opening_loc)) {
-    return is_closing_brace(closing_loc);
+  if (keyword_offset != UINT32_MAX && (!context->found || keyword_offset < context->offset)) {
+    context->offset = keyword_offset;
+    context->found = true;
   }
 
+  pm_visit_child_nodes(node, search_inline_condition_offset, context);
+
   return false;
 }
 
-bool search_block_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_BLOCK_NODE) {
-    pm_block_node_t* block_node = (pm_block_node_t*) node;
+static hb_string_T control_continuation_keywords[] = HB_STRING_LIST("else", "elsif", "when", "in", "rescue", "ensure");
+static hb_string_T control_terminator_keywords[] = HB_STRING_LIST("end", "}");
 
-    bool has_opening = is_do_block(block_node->opening_loc) || is_brace_block(block_node->opening_loc);
-    bool is_unclosed = !has_valid_block_closing(block_node->opening_loc, block_node->closing_loc);
-
-    if (has_opening && is_unclosed) { analyzed->block_node_count++; }
-  }
-
-  if (node->type == PM_LAMBDA_NODE) {
-    pm_lambda_node_t* lambda_node = (pm_lambda_node_t*) node;
-
-    bool has_opening = is_do_block(lambda_node->opening_loc) || is_brace_block(lambda_node->opening_loc);
-    bool is_unclosed = !has_valid_block_closing(lambda_node->opening_loc, lambda_node->closing_loc);
-
-    if (has_opening && is_unclosed) { analyzed->block_node_count++; }
+static bool matches_keyword(hb_string_T keyword, const hb_string_T* keywords, size_t count) {
+  for (size_t index = 0; index < count; index++) {
+    if (hb_string_equals(keyword, keywords[index])) { return true; }
   }
 
-  pm_visit_child_nodes(node, search_block_nodes, analyzed);
-
   return false;
 }
 
-bool search_case_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_CASE_NODE) { analyzed->case_node_count++; }
-
-  pm_visit_child_nodes(node, search_case_nodes, analyzed);
-
-  return false;
+static bool is_control_continuation_keyword(hb_string_T keyword) {
+  return matches_keyword(
+    keyword,
+    control_continuation_keywords,
+    sizeof(control_continuation_keywords) / sizeof(control_continuation_keywords[0])
+  );
 }
 
-bool search_case_match_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_CASE_MATCH_NODE) { analyzed->case_match_node_count++; }
-
-  pm_visit_child_nodes(node, search_case_match_nodes, analyzed);
-
-  return false;
+static bool is_control_role_keyword(hb_string_T keyword) {
+  return is_control_continuation_keyword(keyword)
+      || matches_keyword(
+           keyword,
+           control_terminator_keywords,
+           sizeof(control_terminator_keywords) / sizeof(control_terminator_keywords[0])
+      );
 }
 
-bool search_while_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+bool control_role_split_offset(const analyzed_ruby_T* analyzed, uint32_t* offset) {
+  if (!analyzed || !offset) { return false; }
 
-  if (node->type == PM_WHILE_NODE) { analyzed->while_node_count++; }
+  uint32_t first = UINT32_MAX;
+  uint32_t second = UINT32_MAX;
+  bool first_continues = false;
 
-  pm_visit_child_nodes(node, search_while_nodes, analyzed);
+  for (const pm_diagnostic_t* diagnostic = (const pm_diagnostic_t*) analyzed->parser.error_list.head;
+       diagnostic != NULL;
+       diagnostic = (const pm_diagnostic_t*) diagnostic->node.next) {
+    if (diagnostic->diag_id != PM_ERR_UNEXPECTED_TOKEN_IGNORE) { continue; }
 
-  return false;
-}
-
-bool search_for_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_FOR_NODE) { analyzed->for_node_count++; }
+    hb_string_T keyword = hb_string_from_data(
+      (const char*) diagnostic->location.start,
+      (size_t) (diagnostic->location.end - diagnostic->location.start)
+    );
 
-  pm_visit_child_nodes(node, search_for_nodes, analyzed);
+    if (!is_control_role_keyword(keyword)) { continue; }
 
-  return false;
-}
+    uint32_t start = (uint32_t) (diagnostic->location.start - analyzed->parser.start);
 
-bool search_until_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+    if (start < first) {
+      second = first;
+      first = start;
+      first_continues = is_control_continuation_keyword(keyword);
+    } else if (start < second) {
+      second = start;
+    }
+  }
 
-  if (node->type == PM_UNTIL_NODE) { analyzed->until_node_count++; }
+  if (second == UINT32_MAX) { return false; }
+  if (!first_continues) { return false; }
 
-  pm_visit_child_nodes(node, search_until_nodes, analyzed);
+  *offset = second;
 
-  return false;
+  return true;
 }
 
-bool search_begin_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+bool has_inline_pattern_match(analyzed_ruby_T* analyzed, hb_string_T content) {
+  if (!has_case_match_node(analyzed) || !has_in_node(analyzed)) { return false; }
 
-  if (node->type == PM_BEGIN_NODE) { analyzed->begin_node_count++; }
+  uint32_t offset = 0;
 
-  pm_visit_child_nodes(node, search_begin_nodes, analyzed);
+  if (!inline_condition_keyword_offset(analyzed, &offset)) { return false; }
+  if (offset > content.length) { return false; }
 
-  return false;
+  return memchr(content.data, '\n', offset) == NULL;
 }
 
-bool search_unless_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_UNLESS_NODE) {
-    const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
-
-    bool has_if_keyword = unless_node->keyword_loc.start != NULL && unless_node->keyword_loc.end != NULL;
-    bool has_end_keyword = unless_node->end_keyword_loc.start != NULL && unless_node->end_keyword_loc.end != NULL;
+bool inline_condition_keyword_offset(const analyzed_ruby_T* analyzed, uint32_t* offset) {
+  if (!analyzed || !analyzed->root || !offset) { return false; }
 
-    if (has_if_keyword && has_end_keyword) { analyzed->unless_node_count++; }
-  }
+  inline_condition_offset_T context = {
+    .source_start = analyzed->parser.start,
+    .offset = UINT32_MAX,
+    .found = false,
+  };
 
-  pm_visit_child_nodes(node, search_unless_nodes, analyzed);
-
-  return false;
-}
-
-bool search_when_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+  pm_visit_node(analyzed->root, search_inline_condition_offset, &context);
 
-  if (node->type == PM_WHEN_NODE) { analyzed->when_node_count++; }
+  if (!context.found) { return false; }
 
-  pm_visit_child_nodes(node, search_when_nodes, analyzed);
+  *offset = context.offset;
 
-  return false;
+  return true;
 }
 
-bool search_in_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_IN_NODE) { analyzed->in_node_count++; }
-  if (node->type == PM_CASE_MATCH_NODE) {
-    const pm_case_match_node_t* case_match_node = (const pm_case_match_node_t*) node;
-
-    if (case_match_node->predicate != NULL && case_match_node->predicate->type == PM_MATCH_PREDICATE_NODE) {
-      analyzed->in_node_count++;
-    }
+bool has_error_message(analyzed_ruby_T* analyzed, const char* message) {
+  for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) analyzed->parser.error_list.head; error != NULL;
+       error = (const pm_diagnostic_t*) error->node.next) {
+    if (string_equals(error->message, message)) { return true; }
   }
 
-  pm_visit_child_nodes(node, search_in_nodes, analyzed);
-
   return false;
 }
 
-bool search_unexpected_elsif_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'elsif', ignoring it")) {
-    analyzed->elsif_node_count++;
-    return true;
-  }
+bool is_do_block(pm_location_t opening_location) {
+  size_t length = opening_location.end - opening_location.start;
 
-  return false;
+  return length == 2 && opening_location.start[0] == 'd' && opening_location.start[1] == 'o';
 }
 
-bool search_unexpected_else_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'else', ignoring it")) {
-    analyzed->else_node_count++;
-    return true;
-  }
+bool is_brace_block(pm_location_t opening_location) {
+  size_t length = opening_location.end - opening_location.start;
 
-  return false;
+  return length == 1 && opening_location.start[0] == '{';
 }
 
-bool search_unexpected_end_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'end', ignoring it")) {
-    if (has_error_message(analyzed, "unexpected '=', ignoring it")) {
-      // `=end`
-      return false;
-    }
-
-    analyzed->end_count++;
-    return true;
-  }
-
-  return false;
+static bool has_location(pm_location_t location) {
+  return location.start != NULL && location.end != NULL && (location.end - location.start) > 0;
 }
 
-bool search_unexpected_block_closing_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected '}', ignoring it")) {
-    analyzed->block_closing_count++;
-    return true;
-  }
-
-  return false;
-}
+static bool is_end_keyword(pm_location_t location) {
+  if (location.start == NULL || location.end == NULL) { return false; }
 
-bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'when', ignoring it")) {
-    analyzed->when_node_count++;
-    return true;
-  }
+  size_t length = location.end - location.start;
 
-  return false;
+  return length == 3 && location.start[0] == 'e' && location.start[1] == 'n' && location.start[2] == 'd';
 }
 
-bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'in', ignoring it")) {
-    analyzed->in_node_count++;
-    return true;
-  }
-
-  return false;
-}
+bool is_closing_brace(pm_location_t location) {
+  if (location.start == NULL || location.end == NULL) { return false; }
 
-bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'rescue', ignoring it")) {
-    analyzed->rescue_node_count++;
-    return true;
-  }
+  size_t length = location.end - location.start;
 
-  return false;
+  return length == 1 && location.start[0] == '}';
 }
 
-bool search_unexpected_ensure_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'ensure', ignoring it")) {
-    analyzed->ensure_node_count++;
-    return true;
+bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc) {
+  if (is_do_block(opening_loc)) {
+    return is_end_keyword(closing_loc);
+  } else if (is_brace_block(opening_loc)) {
+    return is_closing_brace(closing_loc);
   }
 
   return false;
 }
 
-bool search_yield_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_YIELD_NODE) { analyzed->yield_node_count++; }
+static bool has_keyword_location(pm_location_t location) {
+  return location.start != NULL && location.end != NULL;
+}
 
-  pm_visit_child_nodes(node, search_yield_nodes, analyzed);
+static bool is_unclosed_block(pm_location_t opening_loc, pm_location_t closing_loc) {
+  bool has_opening = is_do_block(opening_loc) || is_brace_block(opening_loc);
 
-  return false;
+  return has_opening && !has_valid_block_closing(opening_loc, closing_loc);
 }
 
-bool search_then_keywords(const pm_node_t* node, void* data) {
+bool search_control_flow_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
   switch (node->type) {
     case PM_IF_NODE: {
       const pm_if_node_t* if_node = (const pm_if_node_t*) node;
-      if (if_node->then_keyword_loc.start != NULL && if_node->then_keyword_loc.end != NULL) {
-        analyzed->then_keyword_count++;
+
+      if (has_keyword_location(if_node->if_keyword_loc) && has_keyword_location(if_node->end_keyword_loc)) {
+        analyzed->if_node_count++;
       }
+
+      if (has_keyword_location(if_node->then_keyword_loc)) { analyzed->then_keyword_count++; }
       break;
     }
 
     case PM_UNLESS_NODE: {
       const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
-      if (unless_node->then_keyword_loc.start != NULL && unless_node->then_keyword_loc.end != NULL) {
-        analyzed->then_keyword_count++;
+
+      if (has_keyword_location(unless_node->keyword_loc) && has_keyword_location(unless_node->end_keyword_loc)) {
+        analyzed->unless_node_count++;
       }
+
+      if (has_keyword_location(unless_node->then_keyword_loc)) { analyzed->then_keyword_count++; }
       break;
     }
 
     case PM_WHEN_NODE: {
       const pm_when_node_t* when_node = (const pm_when_node_t*) node;
-      if (when_node->then_keyword_loc.start != NULL && when_node->then_keyword_loc.end != NULL) {
-        analyzed->then_keyword_count++;
+
+      analyzed->when_node_count++;
+
+      if (has_keyword_location(when_node->then_keyword_loc)) { analyzed->then_keyword_count++; }
+      break;
+    }
+
+    case PM_BLOCK_NODE: {
+      const pm_block_node_t* block_node = (const pm_block_node_t*) node;
+
+      if (is_unclosed_block(block_node->opening_loc, block_node->closing_loc)) { analyzed->block_node_count++; }
+      break;
+    }
+
+    case PM_LAMBDA_NODE: {
+      const pm_lambda_node_t* lambda_node = (const pm_lambda_node_t*) node;
+
+      if (is_unclosed_block(lambda_node->opening_loc, lambda_node->closing_loc)) { analyzed->block_node_count++; }
+      break;
+    }
+
+    case PM_CASE_MATCH_NODE: {
+      const pm_case_match_node_t* case_match_node = (const pm_case_match_node_t*) node;
+
+      analyzed->case_match_node_count++;
+
+      if (case_match_node->predicate != NULL && case_match_node->predicate->type == PM_MATCH_PREDICATE_NODE) {
+        analyzed->in_node_count++;
       }
       break;
     }
 
+    case PM_CASE_NODE: analyzed->case_node_count++; break;
+    case PM_IN_NODE: analyzed->in_node_count++; break;
+    case PM_WHILE_NODE: analyzed->while_node_count++; break;
+    case PM_FOR_NODE: analyzed->for_node_count++; break;
+    case PM_UNTIL_NODE: analyzed->until_node_count++; break;
+    case PM_BEGIN_NODE: analyzed->begin_node_count++; break;
+    case PM_YIELD_NODE: analyzed->yield_node_count++; break;
+
     default: break;
   }
 
-  pm_visit_child_nodes(node, search_then_keywords, analyzed);
+  pm_visit_child_nodes(node, search_control_flow_nodes, analyzed);
 
   return false;
 }
 
+void search_unexpected_keyword_errors(analyzed_ruby_T* analyzed) {
+  bool unexpected_elsif = false;
+  bool unexpected_else = false;
+  bool unexpected_end = false;
+  bool unexpected_equals = false;
+  bool unexpected_closing_brace = false;
+  bool unexpected_when = false;
+  bool unexpected_in = false;
+  bool unexpected_rescue = false;
+  bool unexpected_ensure = false;
+
+  for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) analyzed->parser.error_list.head; error != NULL;
+       error = (const pm_diagnostic_t*) error->node.next) {
+    const char* message = error->message;
+
+    if (string_equals(message, "unexpected 'elsif', ignoring it")) {
+      unexpected_elsif = true;
+    } else if (string_equals(message, "unexpected 'else', ignoring it")) {
+      unexpected_else = true;
+    } else if (string_equals(message, "unexpected 'end', ignoring it")) {
+      unexpected_end = true;
+    } else if (string_equals(message, "unexpected '=', ignoring it")) {
+      unexpected_equals = true;
+    } else if (string_equals(message, "unexpected '}', ignoring it")) {
+      unexpected_closing_brace = true;
+    } else if (string_equals(message, "unexpected 'when', ignoring it")) {
+      unexpected_when = true;
+    } else if (string_equals(message, "unexpected 'in', ignoring it")) {
+      unexpected_in = true;
+    } else if (string_equals(message, "unexpected 'rescue', ignoring it")) {
+      unexpected_rescue = true;
+    } else if (string_equals(message, "unexpected 'ensure', ignoring it")) {
+      unexpected_ensure = true;
+    }
+  }
+
+  if (unexpected_elsif) { analyzed->elsif_node_count++; }
+  if (unexpected_else) { analyzed->else_node_count++; }
+  if (unexpected_end && !unexpected_equals) { analyzed->end_count++; }
+  if (unexpected_when) { analyzed->when_node_count++; }
+  if (unexpected_in) { analyzed->in_node_count++; }
+  if (unexpected_rescue) { analyzed->rescue_node_count++; }
+  if (unexpected_ensure) { analyzed->ensure_node_count++; }
+  if (unexpected_closing_brace) { analyzed->block_closing_count++; }
+}
+
 static bool is_postfix_conditional(const pm_statements_node_t* statements, pm_location_t keyword_location) {
   if (statements == NULL) { return false; }
 
@@ -616,6 +603,122 @@ static void append_parameter(
   );
 }
 
+static void append_required_positional(
+  hb_array_T* result,
+  pm_node_t* node,
+  pm_parser_t* parser,
+  const char* source,
+  size_t source_base_offset,
+  const uint8_t* prism_source_start,
+  hb_allocator_T* allocator
+);
+
+static void append_multi_target_parameters(
+  hb_array_T* result,
+  pm_multi_target_node_t* multi_target,
+  pm_parser_t* parser,
+  const char* source,
+  size_t source_base_offset,
+  const uint8_t* prism_source_start,
+  hb_allocator_T* allocator
+) {
+  for (size_t index = 0; index < multi_target->lefts.size; index++) {
+    append_required_positional(
+      result,
+      multi_target->lefts.nodes[index],
+      parser,
+      source,
+      source_base_offset,
+      prism_source_start,
+      allocator
+    );
+  }
+
+  if (multi_target->rest && multi_target->rest->type == PM_SPLAT_NODE) {
+    pm_splat_node_t* splat = (pm_splat_node_t*) multi_target->rest;
+
+    if (splat->expression && splat->expression->type == PM_REQUIRED_PARAMETER_NODE) {
+      pm_required_parameter_node_t* required = (pm_required_parameter_node_t*) splat->expression;
+      pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, required->name);
+
+      if (constant) {
+        char* name = hb_allocator_strndup(allocator, (const char*) constant->start, constant->length);
+        pm_node_t* node = splat->expression;
+
+        append_parameter(
+          result,
+          create_parameter_name_token(node->location, name, prism_source_start, source_base_offset, source, allocator),
+          NULL,
+          "rest",
+          false,
+          prism_to_source_position(node->location.start, prism_source_start, source_base_offset, source),
+          prism_to_source_position(node->location.end, prism_source_start, source_base_offset, source),
+          allocator
+        );
+
+        hb_allocator_dealloc(allocator, name);
+      }
+    }
+  }
+
+  for (size_t index = 0; index < multi_target->rights.size; index++) {
+    append_required_positional(
+      result,
+      multi_target->rights.nodes[index],
+      parser,
+      source,
+      source_base_offset,
+      prism_source_start,
+      allocator
+    );
+  }
+}
+
+static void append_required_positional(
+  hb_array_T* result,
+  pm_node_t* node,
+  pm_parser_t* parser,
+  const char* source,
+  size_t source_base_offset,
+  const uint8_t* prism_source_start,
+  hb_allocator_T* allocator
+) {
+  if (node->type == PM_MULTI_TARGET_NODE) {
+    append_multi_target_parameters(
+      result,
+      (pm_multi_target_node_t*) node,
+      parser,
+      source,
+      source_base_offset,
+      prism_source_start,
+      allocator
+    );
+
+    return;
+  }
+
+  if (node->type != PM_REQUIRED_PARAMETER_NODE) { return; }
+
+  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) { return; }
+
+  char* name = hb_allocator_strndup(allocator, (const char*) constant->start, constant->length);
+
+  append_parameter(
+    result,
+    create_parameter_name_token(node->location, name, prism_source_start, source_base_offset, source, allocator),
+    NULL,
+    "positional",
+    true,
+    prism_to_source_position(node->location.start, prism_source_start, source_base_offset, source),
+    prism_to_source_position(node->location.end, prism_source_start, source_base_offset, source),
+    allocator
+  );
+
+  hb_allocator_dealloc(allocator, name);
+}
+
 hb_array_T* extract_parameters_from_prism(
   pm_parameters_node_t* parameters,
   pm_parser_t* parser,
@@ -633,31 +736,17 @@ hb_array_T* extract_parameters_from_prism(
 
   hb_array_T* result = hb_array_init(count, allocator);
 
-  // Required positional: |item|
+  // Required positional: |item|, including destructured |(key, value)|
   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(
+    append_required_positional(
       result,
-      create_parameter_name_token(node->location, name, prism_source_start, source_base_offset, source, allocator),
-      NULL,
-      "positional",
-      true,
-      start,
-      end,
+      parameters->requireds.nodes[index],
+      parser,
+      source,
+      source_base_offset,
+      prism_source_start,
       allocator
     );
-
-    hb_allocator_dealloc(allocator, name);
   }
 
   // Optional positional: |item = nil|
@@ -731,9 +820,33 @@ hb_array_T* extract_parameters_from_prism(
       );
 
       hb_allocator_dealloc(allocator, name);
+    } else {
+      append_parameter(
+        result,
+        NULL,
+        NULL,
+        "rest",
+        false,
+        prism_to_source_position(parameters->rest->location.start, prism_source_start, source_base_offset, source),
+        prism_to_source_position(parameters->rest->location.end, prism_source_start, source_base_offset, source),
+        allocator
+      );
     }
   }
 
+  // Post-rest positional: the |last| in |item, *rest, last|
+  for (size_t index = 0; index < parameters->posts.size; index++) {
+    append_required_positional(
+      result,
+      parameters->posts.nodes[index],
+      parser,
+      source,
+      source_base_offset,
+      prism_source_start,
+      allocator
+    );
+  }
+
   // Keywords: |name:| or |title: "default"|
   for (size_t index = 0; index < parameters->keywords.size; index++) {
     pm_node_t* keyword = parameters->keywords.nodes[index];
@@ -880,6 +993,17 @@ hb_array_T* extract_parameters_from_prism(
       );
 
       hb_allocator_dealloc(allocator, name);
+    } else {
+      append_parameter(
+        result,
+        NULL,
+        NULL,
+        "block",
+        false,
+        prism_to_source_position(block_param->base.location.start, prism_source_start, source_base_offset, source),
+        prism_to_source_position(block_param->base.location.end, prism_source_start, source_base_offset, source),
+        allocator
+      );
     }
   }
 
@@ -889,7 +1013,7 @@ hb_array_T* extract_parameters_from_prism(
 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_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); }
@@ -925,7 +1049,7 @@ hb_array_T* extract_block_arguments_from_erb_node(
       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);
+      hb_array_append_lazy(errors, parse_error, allocator);
     }
   }
 
@@ -938,3 +1062,138 @@ hb_array_T* extract_block_arguments_from_erb_node(
     allocator
   );
 }
+
+bool is_erb_output_tag(const 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 bool is_escape_neutral(hb_string_T content) {
+  for (uint32_t index = 0; index < content.length; index++) {
+    switch (content.data[index]) {
+      case '&':
+      case '<':
+      case '>':
+      case '"':
+      case '\'': return false;
+
+      default: break;
+    }
+  }
+
+  return true;
+}
+
+static bool is_plain_decimal_integer(hb_string_T source) {
+  uint32_t index = (source.length > 0 && source.data[0] == '-') ? 1 : 0;
+
+  if (index >= source.length) { return false; }
+  if (source.data[index] == '0' && (source.length - index) > 1) { return false; }
+
+  for (uint32_t position = index; position < source.length; position++) {
+    if (source.data[position] < '0' || source.data[position] > '9') { return false; }
+  }
+
+  return true;
+}
+
+static bool prism_node_static_output(const pm_node_t* node, hb_string_T* output) {
+  if (!node || !output) { return false; }
+
+  switch (node->type) {
+    case PM_STRING_NODE: {
+      const pm_string_t* unescaped = &((const pm_string_node_t*) node)->unescaped;
+
+      *output = hb_string_from_data((const char*) pm_string_source(unescaped), pm_string_length(unescaped));
+      break;
+    }
+
+    case PM_SYMBOL_NODE: {
+      const pm_string_t* unescaped = &((const pm_symbol_node_t*) node)->unescaped;
+
+      *output = hb_string_from_data((const char*) pm_string_source(unescaped), pm_string_length(unescaped));
+      break;
+    }
+
+    case PM_INTEGER_NODE: {
+      hb_string_T source =
+        hb_string_from_data((const char*) node->location.start, (size_t) (node->location.end - node->location.start));
+
+      if (!is_plain_decimal_integer(source)) { return false; }
+
+      *output = source;
+      break;
+    }
+
+    case PM_TRUE_NODE: *output = hb_string("true"); break;
+    case PM_FALSE_NODE: *output = hb_string("false"); break;
+    case PM_NIL_NODE: *output = HB_STRING_EMPTY; break;
+
+    default: return false;
+  }
+
+  return is_escape_neutral(*output);
+}
+
+static AST_NODE_T* create_static_output_node(
+  hb_string_T content,
+  static_output_node_type_T node_type,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+) {
+  switch (node_type) {
+    case STATIC_OUTPUT_NODE_HTML_TEXT:
+      return (
+        AST_NODE_T*
+      ) ast_html_text_node_init(content, start_position, end_position, hb_array_init(0, allocator), allocator);
+
+    case STATIC_OUTPUT_NODE_LITERAL:
+      return (
+        AST_NODE_T*
+      ) ast_literal_node_init(content, start_position, end_position, hb_array_init(0, allocator), allocator);
+
+    default: return NULL;
+  }
+}
+
+bool append_static_output_node(
+  hb_array_T* statements,
+  const pm_statements_node_t* body,
+  const analyzed_ruby_T* analyzed,
+  position_T content_start,
+  static_output_node_type_T node_type,
+  hb_allocator_T* allocator
+) {
+  if (!statements || !body || !analyzed) { return false; }
+  if (node_type == STATIC_OUTPUT_NODE_NONE) { return false; }
+  if (body->body.size != 1) { return false; }
+
+  const pm_node_t* literal = body->body.nodes[0];
+  const uint8_t* parser_start = analyzed->parser.start;
+
+  if (literal->location.start < parser_start || literal->location.end > analyzed->parser.end) { return false; }
+
+  hb_string_T content;
+
+  if (!prism_node_static_output(literal, &content)) { return false; }
+  if (content.length == 0) { return true; }
+
+  size_t offset = (size_t) (literal->location.start - parser_start);
+  size_t length = (size_t) (literal->location.end - literal->location.start);
+
+  position_T start_position = { .line = content_start.line, .column = content_start.column + (uint32_t) offset };
+  position_T end_position = { .line = content_start.line,
+                              .column = content_start.column + (uint32_t) (offset + length) };
+
+  AST_NODE_T* node = create_static_output_node(content, node_type, start_position, end_position, allocator);
+
+  if (!node) { return false; }
+
+  hb_array_append(statements, node);
+
+  return true;
+}