@herb-tools/node 0.8.10 → 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,87 +2,92 @@
 #include <stdbool.h>
 #include <string.h>
 
-#include "include/analyzed_ruby.h"
-#include "include/util/string.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 (string_equals(error->message, message)) { return true; }
   }
@@ -161,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;
@@ -494,6 +508,17 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
       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;
+    }
+
     default: 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);
 
@@ -58,6 +60,6 @@ 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

package/extension/libherb/analyze/invalid_structures.c

@@ -0,0 +1,193 @@
+#include "../include/analyze/invalid_structures.h"
+#include "../include/analyze/analyze.h"
+#include "../include/analyze/analyzed_ruby.h"
+#include "../include/analyze/helpers.h"
+#include "../include/ast_node.h"
+#include "../include/ast_nodes.h"
+#include "../include/errors.h"
+#include "../include/token_struct.h"
+#include "../include/util/hb_array.h"
+#include "../include/util/hb_string.h"
+#include "../include/visitor.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+bool detect_invalid_erb_structures(const AST_NODE_T* node, void* data) {
+  invalid_erb_context_T* context = (invalid_erb_context_T*) data;
+
+  if (node->type == AST_HTML_ATTRIBUTE_NAME_NODE) { return false; }
+
+  bool is_begin_node = (node->type == AST_ERB_BEGIN_NODE);
+  bool is_loop_node =
+    (node->type == AST_ERB_WHILE_NODE || node->type == AST_ERB_UNTIL_NODE || node->type == AST_ERB_FOR_NODE
+     || node->type == AST_ERB_BLOCK_NODE);
+
+  if (is_loop_node) { context->loop_depth++; }
+  if (is_begin_node) { context->rescue_depth++; }
+
+  if (node->type == AST_ERB_CONTENT_NODE) {
+    const AST_ERB_CONTENT_NODE_T* content_node = (const AST_ERB_CONTENT_NODE_T*) node;
+
+    if (content_node->parsed && !content_node->valid && content_node->analyzed_ruby != NULL) {
+      analyzed_ruby_T* analyzed = content_node->analyzed_ruby;
+
+      // =begin
+      if (has_error_message(analyzed, "embedded document meets end of file")) {
+        if (is_loop_node) { context->loop_depth--; }
+        if (is_begin_node) { context->rescue_depth--; }
+
+        return true;
+      }
+
+      // =end
+      if (has_error_message(analyzed, "unexpected '=', ignoring it")
+          && has_error_message(analyzed, "unexpected 'end', ignoring it")) {
+        if (is_loop_node) { context->loop_depth--; }
+        if (is_begin_node) { context->rescue_depth--; }
+
+        return true;
+      }
+
+      hb_string_T keyword = HB_STRING_NULL;
+
+      if (context->loop_depth == 0) {
+        if (has_error_message(analyzed, "Invalid break")) {
+          keyword = hb_string("`<% break %>`");
+        } else if (has_error_message(analyzed, "Invalid next")) {
+          keyword = hb_string("`<% next %>`");
+        } else if (has_error_message(analyzed, "Invalid redo")) {
+          keyword = hb_string("`<% redo %>`");
+        }
+      } else {
+        if (has_error_message(analyzed, "Invalid redo") || has_error_message(analyzed, "Invalid break")
+            || has_error_message(analyzed, "Invalid next")) {
+
+          if (is_loop_node) { context->loop_depth--; }
+          if (is_begin_node) { context->rescue_depth--; }
+
+          return true;
+        }
+      }
+
+      if (context->rescue_depth == 0) {
+        if (has_error_message(analyzed, "Invalid retry without rescue")) { keyword = hb_string("`<% retry %>`"); }
+      } else {
+        if (has_error_message(analyzed, "Invalid retry without rescue")) {
+          if (is_loop_node) { context->loop_depth--; }
+          if (is_begin_node) { context->rescue_depth--; }
+
+          return true;
+        }
+      }
+
+      if (hb_string_is_null(keyword)) { keyword = erb_keyword_from_analyzed_ruby(analyzed); }
+
+      if (!hb_string_is_null(keyword) && !token_value_empty(content_node->tag_closing)) {
+        append_erb_control_flow_scope_error(
+          keyword,
+          node->location.start,
+          node->location.end,
+          context->allocator,
+          node->errors
+        );
+      }
+    }
+  }
+
+  if (node->type == AST_ERB_IF_NODE) {
+    const AST_ERB_IF_NODE_T* if_node = (const AST_ERB_IF_NODE_T*) node;
+
+    if (if_node->end_node == NULL) { check_erb_node_for_missing_end(node, context->allocator); }
+
+    if (if_node->statements != NULL) {
+      for (size_t i = 0; i < hb_array_size(if_node->statements); i++) {
+        AST_NODE_T* statement = (AST_NODE_T*) hb_array_get(if_node->statements, i);
+
+        if (statement != NULL) { herb_visit_node(statement, detect_invalid_erb_structures, context); }
+      }
+    }
+
+    AST_NODE_T* subsequent = if_node->subsequent;
+
+    while (subsequent != NULL) {
+      if (subsequent->type == AST_ERB_CONTENT_NODE) {
+        const AST_ERB_CONTENT_NODE_T* content_node = (const AST_ERB_CONTENT_NODE_T*) subsequent;
+
+        if (content_node->parsed && !content_node->valid && content_node->analyzed_ruby != NULL) {
+          analyzed_ruby_T* analyzed = content_node->analyzed_ruby;
+          hb_string_T keyword = erb_keyword_from_analyzed_ruby(analyzed);
+
+          if (!token_value_empty(content_node->tag_closing)) {
+            append_erb_control_flow_scope_error(
+              keyword,
+              subsequent->location.start,
+              subsequent->location.end,
+              context->allocator,
+              subsequent->errors
+            );
+          }
+        }
+      }
+
+      if (subsequent->type == AST_ERB_IF_NODE) {
+        const AST_ERB_IF_NODE_T* elsif_node = (const AST_ERB_IF_NODE_T*) subsequent;
+
+        if (elsif_node->statements != NULL) {
+          for (size_t i = 0; i < hb_array_size(elsif_node->statements); i++) {
+            AST_NODE_T* statement = (AST_NODE_T*) hb_array_get(elsif_node->statements, i);
+
+            if (statement != NULL) { herb_visit_node(statement, detect_invalid_erb_structures, context); }
+          }
+        }
+
+        subsequent = elsif_node->subsequent;
+      } else if (subsequent->type == AST_ERB_ELSE_NODE) {
+        const AST_ERB_ELSE_NODE_T* else_node = (const AST_ERB_ELSE_NODE_T*) subsequent;
+
+        if (else_node->statements != NULL) {
+          for (size_t i = 0; i < hb_array_size(else_node->statements); i++) {
+            AST_NODE_T* statement = (AST_NODE_T*) hb_array_get(else_node->statements, i);
+
+            if (statement != NULL) { herb_visit_node(statement, detect_invalid_erb_structures, context); }
+          }
+        }
+
+        break;
+      } else {
+        break;
+      }
+    }
+  }
+
+  if (node->type == AST_ERB_UNLESS_NODE || node->type == AST_ERB_WHILE_NODE || node->type == AST_ERB_UNTIL_NODE
+      || node->type == AST_ERB_FOR_NODE || node->type == AST_ERB_CASE_NODE || node->type == AST_ERB_CASE_MATCH_NODE
+      || node->type == AST_ERB_BEGIN_NODE || node->type == AST_ERB_BLOCK_NODE || node->type == AST_ERB_ELSE_NODE) {
+    herb_visit_child_nodes(node, detect_invalid_erb_structures, context);
+  }
+
+  if (node->type == AST_ERB_UNLESS_NODE || node->type == AST_ERB_WHILE_NODE || node->type == AST_ERB_UNTIL_NODE
+      || node->type == AST_ERB_FOR_NODE || node->type == AST_ERB_CASE_NODE || node->type == AST_ERB_CASE_MATCH_NODE
+      || node->type == AST_ERB_BEGIN_NODE || node->type == AST_ERB_BLOCK_NODE || node->type == AST_ERB_ELSE_NODE) {
+    check_erb_node_for_missing_end(node, context->allocator);
+
+    if (is_loop_node) { context->loop_depth--; }
+    if (is_begin_node) { context->rescue_depth--; }
+
+    return false;
+  }
+
+  if (node->type == AST_ERB_IF_NODE) {
+    if (is_loop_node) { context->loop_depth--; }
+    if (is_begin_node) { context->rescue_depth--; }
+
+    return false;
+  }
+
+  bool result = true;
+
+  if (is_loop_node) { context->loop_depth--; }
+  if (is_begin_node) { context->rescue_depth--; }
+
+  return result;
+}

package/extension/libherb/analyze/invalid_structures.h

@@ -0,0 +1,11 @@
+#ifndef HERB_ANALYZE_INVALID_STRUCTURES_H
+#define HERB_ANALYZE_INVALID_STRUCTURES_H
+
+#include "../ast_node.h"
+#include "analyze.h"
+
+#include <stdbool.h>
+
+bool detect_invalid_erb_structures(const AST_NODE_T* node, void* data);
+
+#endif