@herb-tools/node 0.8.9 → 0.9.0

package/extension/libherb/analyze/control_type.c

@@ -0,0 +1,250 @@
+#include "../include/analyze/control_type.h"
+#include "../include/analyze/analyze.h"
+#include "../include/analyze/analyzed_ruby.h"
+#include "../include/analyze/helpers.h"
+#include "../include/ast_node.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef struct {
+  control_type_t type;
+  uint32_t offset;
+  bool found;
+} earliest_control_keyword_T;
+
+typedef struct {
+  earliest_control_keyword_T* result;
+  const uint8_t* source_start;
+} location_walker_context_T;
+
+static bool control_type_is_block(control_type_t type) {
+  return type == CONTROL_TYPE_BLOCK;
+}
+
+static bool control_type_is_yield(control_type_t type) {
+  return type == CONTROL_TYPE_YIELD;
+}
+
+static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* data) {
+  if (!node) { return true; }
+
+  location_walker_context_T* context = (location_walker_context_T*) data;
+  earliest_control_keyword_T* result = context->result;
+
+  control_type_t current_type = CONTROL_TYPE_UNKNOWN;
+  uint32_t keyword_offset = UINT32_MAX;
+
+  switch (node->type) {
+    case PM_IF_NODE: {
+      pm_if_node_t* if_node = (pm_if_node_t*) node;
+      current_type = CONTROL_TYPE_IF;
+      keyword_offset = (uint32_t) (if_node->if_keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_UNLESS_NODE: {
+      pm_unless_node_t* unless_node = (pm_unless_node_t*) node;
+      current_type = CONTROL_TYPE_UNLESS;
+      keyword_offset = (uint32_t) (unless_node->keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_CASE_NODE: {
+      pm_case_node_t* case_node = (pm_case_node_t*) node;
+      current_type = CONTROL_TYPE_CASE;
+      keyword_offset = (uint32_t) (case_node->case_keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_CASE_MATCH_NODE: {
+      pm_case_match_node_t* case_match_node = (pm_case_match_node_t*) node;
+      current_type = CONTROL_TYPE_CASE_MATCH;
+      keyword_offset = (uint32_t) (case_match_node->case_keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_WHILE_NODE: {
+      pm_while_node_t* while_node = (pm_while_node_t*) node;
+      current_type = CONTROL_TYPE_WHILE;
+      keyword_offset = (uint32_t) (while_node->keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_UNTIL_NODE: {
+      pm_until_node_t* until_node = (pm_until_node_t*) node;
+      current_type = CONTROL_TYPE_UNTIL;
+      keyword_offset = (uint32_t) (until_node->keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_FOR_NODE: {
+      pm_for_node_t* for_node = (pm_for_node_t*) node;
+      current_type = CONTROL_TYPE_FOR;
+      keyword_offset = (uint32_t) (for_node->for_keyword_loc.start - context->source_start);
+      break;
+    }
+
+    case PM_BEGIN_NODE: {
+      pm_begin_node_t* begin_node = (pm_begin_node_t*) node;
+      current_type = CONTROL_TYPE_BEGIN;
+
+      if (begin_node->begin_keyword_loc.start != NULL) {
+        keyword_offset = (uint32_t) (begin_node->begin_keyword_loc.start - context->source_start);
+      } else {
+        keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      }
+      break;
+    }
+
+    case PM_YIELD_NODE: {
+      current_type = CONTROL_TYPE_YIELD;
+      keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      break;
+    }
+
+    case PM_CALL_NODE: {
+      pm_call_node_t* call = (pm_call_node_t*) node;
+
+      if (call->block != NULL && call->block->type == PM_BLOCK_NODE) {
+        pm_block_node_t* block_node = (pm_block_node_t*) call->block;
+
+        bool has_do_opening = is_do_block(block_node->opening_loc);
+        bool has_brace_opening = is_brace_block(block_node->opening_loc);
+        bool has_valid_brace_closing = is_closing_brace(block_node->closing_loc);
+
+        if (has_do_opening || (has_brace_opening && !has_valid_brace_closing)) {
+          current_type = CONTROL_TYPE_BLOCK;
+          keyword_offset = (uint32_t) (node->location.start - context->source_start);
+        }
+      }
+      break;
+    }
+
+    case PM_LAMBDA_NODE: {
+      pm_lambda_node_t* lambda = (pm_lambda_node_t*) node;
+
+      bool has_do_opening = is_do_block(lambda->opening_loc);
+      bool has_brace_opening = is_brace_block(lambda->opening_loc);
+      bool has_valid_brace_closing = is_closing_brace(lambda->closing_loc);
+
+      if (has_do_opening || (has_brace_opening && !has_valid_brace_closing)) {
+        current_type = CONTROL_TYPE_BLOCK;
+        keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      }
+
+      break;
+    }
+
+    case PM_NEXT_NODE:
+    case PM_BREAK_NODE:
+    case PM_RETURN_NODE: {
+      current_type = CONTROL_TYPE_UNKNOWN;
+      keyword_offset = (uint32_t) (node->location.start - context->source_start);
+      break;
+    }
+
+    default: break;
+  }
+
+  if (keyword_offset != UINT32_MAX) {
+    bool should_update = !result->found;
+
+    if (result->found) {
+      if (control_type_is_block(current_type) && control_type_is_yield(result->type)) {
+        should_update = true;
+      } else if (!(control_type_is_yield(current_type) && control_type_is_block(result->type))) {
+        should_update = keyword_offset < result->offset;
+      }
+    }
+
+    if (should_update) {
+      result->type = current_type;
+      result->offset = keyword_offset;
+      result->found = true;
+    }
+  }
+
+  return true;
+}
+
+static control_type_t find_earliest_control_keyword(pm_node_t* root, const uint8_t* source_start) {
+  if (!root) { return CONTROL_TYPE_UNKNOWN; }
+
+  earliest_control_keyword_T result = { .type = CONTROL_TYPE_UNKNOWN, .offset = UINT32_MAX, .found = false };
+
+  location_walker_context_T context = { .result = &result, .source_start = source_start };
+
+  pm_visit_node(root, find_earliest_control_keyword_walker, &context);
+
+  return result.found ? result.type : CONTROL_TYPE_UNKNOWN;
+}
+
+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; }
+
+  analyzed_ruby_T* ruby = erb_node->analyzed_ruby;
+
+  if (!ruby) { return CONTROL_TYPE_UNKNOWN; }
+  if (ruby->valid) { return CONTROL_TYPE_UNKNOWN; }
+
+  pm_node_t* root = ruby->root;
+
+  if (has_elsif_node(ruby)) { return CONTROL_TYPE_ELSIF; }
+  if (has_else_node(ruby)) { return CONTROL_TYPE_ELSE; }
+  if (has_end(ruby)) { return CONTROL_TYPE_END; }
+  if (has_when_node(ruby) && !has_case_node(ruby)) { return CONTROL_TYPE_WHEN; }
+  if (has_in_node(ruby) && !has_case_match_node(ruby)) { return CONTROL_TYPE_IN; }
+  if (has_rescue_node(ruby)) { return CONTROL_TYPE_RESCUE; }
+  if (has_ensure_node(ruby)) { return CONTROL_TYPE_ENSURE; }
+  if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
+
+  if (ruby->unclosed_control_flow_count == 0 && !has_yield_node(ruby)) { return CONTROL_TYPE_UNKNOWN; }
+
+  return find_earliest_control_keyword(root, ruby->parser.start);
+}
+
+bool is_subsequent_type(control_type_t parent_type, control_type_t child_type) {
+  switch (parent_type) {
+    case CONTROL_TYPE_IF:
+    case CONTROL_TYPE_ELSIF: return child_type == CONTROL_TYPE_ELSIF || child_type == CONTROL_TYPE_ELSE;
+    case CONTROL_TYPE_CASE:
+    case CONTROL_TYPE_CASE_MATCH: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
+    case CONTROL_TYPE_BEGIN:
+      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;
+
+    default: return false;
+  }
+}
+
+bool is_terminator_type(control_type_t parent_type, control_type_t child_type) {
+  if (child_type == CONTROL_TYPE_END) { return true; }
+
+  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;
+
+    default: return is_subsequent_type(parent_type, child_type);
+  }
+}
+
+bool is_compound_control_type(control_type_t type) {
+  switch (type) {
+    case CONTROL_TYPE_IF:
+    case CONTROL_TYPE_CASE:
+    case CONTROL_TYPE_CASE_MATCH:
+    case CONTROL_TYPE_BEGIN:
+    case CONTROL_TYPE_UNLESS:
+    case CONTROL_TYPE_WHILE:
+    case CONTROL_TYPE_UNTIL:
+    case CONTROL_TYPE_FOR:
+    case CONTROL_TYPE_BLOCK: return true;
+
+    default: return false;
+  }
+}

package/extension/libherb/analyze/control_type.h

@@ -0,0 +1,14 @@
+#ifndef HERB_ANALYZE_CONTROL_TYPE_H
+#define HERB_ANALYZE_CONTROL_TYPE_H
+
+#include "../ast_nodes.h"
+#include "analyze.h"
+
+#include <stdbool.h>
+
+control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node);
+bool is_subsequent_type(control_type_t parent_type, control_type_t child_type);
+bool is_terminator_type(control_type_t parent_type, control_type_t child_type);
+bool is_compound_control_type(control_type_t type);
+
+#endif

package/extension/libherb/{analyze_helpers.c → analyze/helpers.c}

@@ -2,88 +2,94 @@
 #include <stdbool.h>
 #include <string.h>
 
-#include "include/analyzed_ruby.h"
+#include "../include/analyze/analyzed_ruby.h"
+#include "../include/util/string.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed) {
-  return analyzed->if_node_count > 0;
+  return analyzed && analyzed->if_node_count > 0;
 }
 
 bool has_elsif_node(analyzed_ruby_T* analyzed) {
-  return analyzed->elsif_node_count > 0;
+  return analyzed && analyzed->elsif_node_count > 0;
 }
 
 bool has_else_node(analyzed_ruby_T* analyzed) {
-  return analyzed->else_node_count > 0;
+  return analyzed && analyzed->else_node_count > 0;
 }
 
 bool has_end(analyzed_ruby_T* analyzed) {
-  return analyzed->end_count > 0;
+  return analyzed && analyzed->end_count > 0;
 }
 
 bool has_block_node(analyzed_ruby_T* analyzed) {
-  return analyzed->block_node_count > 0;
+  return analyzed && analyzed->block_node_count > 0;
 }
 
 bool has_block_closing(analyzed_ruby_T* analyzed) {
-  return analyzed->block_closing_count > 0;
+  return analyzed && analyzed->block_closing_count > 0;
 }
 
 bool has_case_node(analyzed_ruby_T* analyzed) {
-  return analyzed->case_node_count > 0;
+  return analyzed && analyzed->case_node_count > 0;
 }
 
 bool has_case_match_node(analyzed_ruby_T* analyzed) {
-  return analyzed->case_match_node_count > 0;
+  return analyzed && analyzed->case_match_node_count > 0;
 }
 
 bool has_when_node(analyzed_ruby_T* analyzed) {
-  return analyzed->when_node_count > 0;
+  return analyzed && analyzed->when_node_count > 0;
 }
 
 bool has_in_node(analyzed_ruby_T* analyzed) {
-  return analyzed->in_node_count > 0;
+  return analyzed && analyzed->in_node_count > 0;
 }
 
 bool has_for_node(analyzed_ruby_T* analyzed) {
-  return analyzed->for_node_count > 0;
+  return analyzed && analyzed->for_node_count > 0;
 }
 
 bool has_while_node(analyzed_ruby_T* analyzed) {
-  return analyzed->while_node_count > 0;
+  return analyzed && analyzed->while_node_count > 0;
 }
 
 bool has_until_node(analyzed_ruby_T* analyzed) {
-  return analyzed->until_node_count > 0;
+  return analyzed && analyzed->until_node_count > 0;
 }
 
 bool has_begin_node(analyzed_ruby_T* analyzed) {
-  return analyzed->begin_node_count > 0;
+  return analyzed && analyzed->begin_node_count > 0;
 }
 
 bool has_rescue_node(analyzed_ruby_T* analyzed) {
-  return analyzed->rescue_node_count > 0;
+  return analyzed && analyzed->rescue_node_count > 0;
 }
 
 bool has_ensure_node(analyzed_ruby_T* analyzed) {
-  return analyzed->ensure_node_count > 0;
+  return analyzed && analyzed->ensure_node_count > 0;
 }
 
 bool has_unless_node(analyzed_ruby_T* analyzed) {
-  return analyzed->unless_node_count > 0;
+  return analyzed && analyzed->unless_node_count > 0;
 }
 
 bool has_yield_node(analyzed_ruby_T* analyzed) {
-  return analyzed->yield_node_count > 0;
+  return analyzed && analyzed->yield_node_count > 0;
 }
 
 bool has_then_keyword(analyzed_ruby_T* analyzed) {
-  return analyzed->then_keyword_count > 0;
+  return analyzed && analyzed->then_keyword_count > 0;
 }
 
-bool has_error_message(analyzed_ruby_T* anlayzed, const char* message) {
-  for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) anlayzed->parser.error_list.head; error != NULL;
+bool has_inline_case_condition(analyzed_ruby_T* analyzed) {
+  return (has_case_node(analyzed) && has_when_node(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 (strcmp(error->message, message) == 0) { return true; }
+    if (string_equals(error->message, message)) { return true; }
   }
 
   return false;
@@ -160,6 +166,15 @@ bool search_block_nodes(const pm_node_t* node, void* data) {
     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++; }
+  }
+
   pm_visit_child_nodes(node, search_block_nodes, analyzed);
 
   return false;
@@ -242,7 +257,28 @@ bool search_unless_nodes(const pm_node_t* node, void* data) {
   return false;
 }
 
-bool search_elsif_nodes(analyzed_ruby_T* analyzed) {
+bool search_when_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_WHEN_NODE) { analyzed->when_node_count++; }
+
+  pm_visit_child_nodes(node, search_when_nodes, analyzed);
+
+  return false;
+}
+
+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_MATCH_PREDICATE_NODE) { analyzed->in_node_count++; }
+
+  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;
@@ -251,7 +287,7 @@ bool search_elsif_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_else_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_else_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'else', ignoring it")) {
     analyzed->else_node_count++;
     return true;
@@ -260,7 +296,7 @@ bool search_else_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_end_nodes(analyzed_ruby_T* analyzed) {
+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`
@@ -274,7 +310,7 @@ bool search_end_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_block_closing_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_block_closing_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected '}', ignoring it")) {
     analyzed->block_closing_count++;
     return true;
@@ -283,7 +319,7 @@ bool search_block_closing_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_when_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'when', ignoring it")) {
     analyzed->when_node_count++;
     return true;
@@ -292,7 +328,7 @@ bool search_when_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_in_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'in', ignoring it")) {
     analyzed->in_node_count++;
     return true;
@@ -301,7 +337,7 @@ bool search_in_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'rescue', ignoring it")) {
     analyzed->rescue_node_count++;
     return true;
@@ -310,7 +346,7 @@ bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_ensure_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_ensure_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'ensure', ignoring it")) {
     analyzed->ensure_node_count++;
     return true;
@@ -468,6 +504,18 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
       if (has_opening && !has_valid_block_closing(block_node->opening_loc, block_node->closing_loc)) {
         analyzed->unclosed_control_flow_count++;
       }
+
+      break;
+    }
+
+    case PM_LAMBDA_NODE: {
+      const pm_lambda_node_t* lambda_node = (const pm_lambda_node_t*) node;
+      bool has_opening = is_do_block(lambda_node->opening_loc) || is_brace_block(lambda_node->opening_loc);
+
+      if (has_opening && !has_valid_block_closing(lambda_node->opening_loc, lambda_node->closing_loc)) {
+        analyzed->unclosed_control_flow_count++;
+      }
+
       break;
     }
 

package/extension/libherb/{analyze_helpers.h → analyze/helpers.h}

@@ -4,8 +4,9 @@
 #include <prism.h>
 #include <stdbool.h>
 
+#include "../ast_node.h"
+#include "../util/hb_allocator.h"
 #include "analyzed_ruby.h"
-#include "ast_node.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed);
 bool has_elsif_node(analyzed_ruby_T* analyzed);
@@ -26,6 +27,7 @@ bool has_ensure_node(analyzed_ruby_T* analyzed);
 bool has_unless_node(analyzed_ruby_T* analyzed);
 bool has_yield_node(analyzed_ruby_T* analyzed);
 bool has_then_keyword(analyzed_ruby_T* analyzed);
+bool has_inline_case_condition(analyzed_ruby_T* analyzed);
 
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
@@ -34,27 +36,30 @@ bool is_brace_block(pm_location_t opening_location);
 bool is_closing_brace(pm_location_t location);
 bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc);
 
-bool search_if_nodes(const pm_node_t* node, void* data);
+bool search_begin_nodes(const pm_node_t* node, void* data);
 bool search_block_nodes(const pm_node_t* node, void* data);
-bool search_case_nodes(const pm_node_t* node, void* data);
 bool search_case_match_nodes(const pm_node_t* node, void* data);
-bool search_while_nodes(const pm_node_t* node, void* data);
+bool search_case_nodes(const pm_node_t* node, void* data);
 bool search_for_nodes(const pm_node_t* node, void* data);
-bool search_until_nodes(const pm_node_t* node, void* data);
-bool search_begin_nodes(const pm_node_t* node, void* data);
-bool search_unless_nodes(const pm_node_t* node, void* data);
-bool search_elsif_nodes(analyzed_ruby_T* analyzed);
-bool search_else_nodes(analyzed_ruby_T* analyzed);
-bool search_end_nodes(analyzed_ruby_T* analyzed);
-bool search_block_closing_nodes(analyzed_ruby_T* analyzed);
-bool search_when_nodes(analyzed_ruby_T* analyzed);
-bool search_in_nodes(analyzed_ruby_T* analyzed);
-bool search_rescue_nodes(analyzed_ruby_T* analyzed);
-bool search_ensure_nodes(analyzed_ruby_T* analyzed);
-bool search_yield_nodes(const pm_node_t* node, void* data);
+bool search_if_nodes(const pm_node_t* node, void* data);
+bool search_in_nodes(const pm_node_t* node, void* data);
 bool search_then_keywords(const pm_node_t* node, void* data);
 bool search_unclosed_control_flows(const pm_node_t* node, void* data);
+bool search_unless_nodes(const pm_node_t* node, void* data);
+bool search_until_nodes(const pm_node_t* node, void* data);
+bool search_when_nodes(const pm_node_t* node, void* data);
+bool search_while_nodes(const pm_node_t* node, void* data);
+bool search_yield_nodes(const pm_node_t* node, void* data);
+
+bool search_unexpected_block_closing_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_else_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_elsif_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_end_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_ensure_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed);
 
-void check_erb_node_for_missing_end(const AST_NODE_T* node);
+void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator);
 
 #endif