herb 0.7.4-x86_64-linux-gnu → 0.8.2-x86_64-linux-gnu

data/src/analyze.c

@@ -1,16 +1,19 @@
 #include "include/analyze.h"
 #include "include/analyze_helpers.h"
 #include "include/analyzed_ruby.h"
-#include "include/array.h"
+#include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
 #include "include/extract.h"
 #include "include/location.h"
+#include "include/parser.h"
 #include "include/position.h"
 #include "include/pretty_print.h"
 #include "include/prism_helpers.h"
 #include "include/token_struct.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_string.h"
 #include "include/visitor.h"
 
 #include <prism.h>
@@ -19,7 +22,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-static analyzed_ruby_T* herb_analyze_ruby(char* source) {
+static analyzed_ruby_T* herb_analyze_ruby(hb_string_T source) {
   analyzed_ruby_T* analyzed = init_analyzed_ruby(source);
 
   pm_visit_node(analyzed->root, search_if_nodes, analyzed);
@@ -52,9 +55,7 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
     const char* opening = erb_content_node->tag_opening->value;
 
     if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0 && strcmp(opening, "<%#") != 0) {
-      analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
-
-      if (false) { pretty_print_analyzed_ruby(analyzed, erb_content_node->content->value); }
+      analyzed_ruby_T* analyzed = herb_analyze_ruby(hb_string(erb_content_node->content->value));
 
       erb_content_node->parsed = true;
       erb_content_node->valid = analyzed->valid;
@@ -73,22 +74,154 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
 
 static size_t process_block_children(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* children_array,
+  hb_array_T* children_array,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 );
 
 static size_t process_subsequent_block(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
   AST_NODE_T** subsequent_out,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 );
 
+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 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) {
+        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) {
+    if (!result->found || keyword_offset < result->offset) {
+      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;
+}
+
 static 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; }
 
@@ -96,31 +229,20 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
 
   if (!ruby) { return CONTROL_TYPE_UNKNOWN; }
 
-  if (ruby->valid) {
-    if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
-    return CONTROL_TYPE_UNKNOWN;
-  }
+  if (ruby->valid) { return CONTROL_TYPE_UNKNOWN; }
+
+  pm_node_t* root = ruby->root;
 
-  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
-  if (has_block_node(ruby)) { return CONTROL_TYPE_BLOCK; }
-  if (has_if_node(ruby)) { return CONTROL_TYPE_IF; }
   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_case_node(ruby)) { return CONTROL_TYPE_CASE; }
-  if (has_case_match_node(ruby)) { return CONTROL_TYPE_CASE_MATCH; }
   if (has_when_node(ruby)) { return CONTROL_TYPE_WHEN; }
   if (has_in_node(ruby)) { return CONTROL_TYPE_IN; }
-  if (has_begin_node(ruby)) { return CONTROL_TYPE_BEGIN; }
   if (has_rescue_node(ruby)) { return CONTROL_TYPE_RESCUE; }
   if (has_ensure_node(ruby)) { return CONTROL_TYPE_ENSURE; }
-  if (has_unless_node(ruby)) { return CONTROL_TYPE_UNLESS; }
-  if (has_while_node(ruby)) { return CONTROL_TYPE_WHILE; }
-  if (has_until_node(ruby)) { return CONTROL_TYPE_UNTIL; }
-  if (has_for_node(ruby)) { return CONTROL_TYPE_FOR; }
   if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
 
-  return CONTROL_TYPE_UNKNOWN;
+  return find_earliest_control_keyword(root, ruby->parser.start);
 }
 
 static bool is_subsequent_type(control_type_t parent_type, control_type_t child_type) {
@@ -152,22 +274,24 @@ static bool is_terminator_type(control_type_t parent_type, control_type_t child_
 
 static AST_NODE_T* create_control_node(
   AST_ERB_CONTENT_NODE_T* erb_node,
-  array_T* children,
+  hb_array_T* children,
   AST_NODE_T* subsequent,
   AST_ERB_END_NODE_T* end_node,
   control_type_t control_type
 ) {
-  array_T* errors = array_init(8);
-  position_T* start_position = erb_node->tag_opening->location->start;
-  position_T* end_position = erb_node->tag_closing->location->end;
+  hb_array_T* errors = erb_node->base.errors;
+  erb_node->base.errors = NULL;
+
+  position_T start_position = erb_node->tag_opening->location.start;
+  position_T end_position = erb_node->tag_closing->location.end;
 
   if (end_node) {
-    end_position = end_node->base.location->end;
-  } else if (children && array_size(children) > 0) {
-    AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
-    end_position = last_child->location->end;
+    end_position = end_node->base.location.end;
+  } else if (children && hb_array_size(children) > 0) {
+    AST_NODE_T* last_child = hb_array_last(children);
+    end_position = last_child->location.end;
   } else if (subsequent) {
-    end_position = subsequent->location->end;
+    end_position = subsequent->location.end;
   }
 
   token_T* tag_opening = erb_node->tag_opening;
@@ -176,7 +300,7 @@ static AST_NODE_T* create_control_node(
 
   switch (control_type) {
     case CONTROL_TYPE_IF:
-    case CONTROL_TYPE_ELSIF:
+    case CONTROL_TYPE_ELSIF: {
       return (AST_NODE_T*) ast_erb_if_node_init(
         tag_opening,
         content,
@@ -188,32 +312,40 @@ static AST_NODE_T* create_control_node(
         end_position,
         errors
       );
+    }
 
-    case CONTROL_TYPE_ELSE:
-      return (AST_NODE_T*)
-        ast_erb_else_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+    case CONTROL_TYPE_ELSE: {
+      return (
+        AST_NODE_T*
+      ) ast_erb_else_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+    }
 
     case CONTROL_TYPE_CASE:
     case CONTROL_TYPE_CASE_MATCH: {
       AST_ERB_ELSE_NODE_T* else_node = NULL;
       if (subsequent && subsequent->type == AST_ERB_ELSE_NODE) { else_node = (AST_ERB_ELSE_NODE_T*) subsequent; }
 
-      array_T* when_conditions = array_init(8);
-      array_T* in_conditions = array_init(8);
-      array_T* non_when_non_in_children = array_init(8);
+      hb_array_T* when_conditions = hb_array_init(8);
+      hb_array_T* in_conditions = hb_array_init(8);
+      hb_array_T* non_when_non_in_children = hb_array_init(8);
+
+      for (size_t i = 0; i < hb_array_size(children); i++) {
+        AST_NODE_T* child = hb_array_get(children, i);
 
-      for (size_t i = 0; i < array_size(children); i++) {
-        AST_NODE_T* child = array_get(children, i);
         if (child && child->type == AST_ERB_WHEN_NODE) {
-          array_append(when_conditions, child);
+          hb_array_append(when_conditions, child);
         } else if (child && child->type == AST_ERB_IN_NODE) {
-          array_append(in_conditions, child);
+          hb_array_append(in_conditions, child);
         } else {
-          array_append(non_when_non_in_children, child);
+          hb_array_append(non_when_non_in_children, child);
         }
       }
 
-      if (array_size(in_conditions) > 0) {
+      hb_array_free(&children);
+
+      if (hb_array_size(in_conditions) > 0) {
+        hb_array_free(&when_conditions);
+
         return (AST_NODE_T*) ast_erb_case_match_node_init(
           tag_opening,
           content,
@@ -226,30 +358,34 @@ static AST_NODE_T* create_control_node(
           end_position,
           errors
         );
-      }
+      } else {
+        hb_array_free(&in_conditions);
 
-      return (AST_NODE_T*) ast_erb_case_node_init(
-        tag_opening,
-        content,
-        tag_closing,
-        non_when_non_in_children,
-        when_conditions,
-        else_node,
-        end_node,
-        start_position,
-        end_position,
-        errors
-      );
+        return (AST_NODE_T*) ast_erb_case_node_init(
+          tag_opening,
+          content,
+          tag_closing,
+          non_when_non_in_children,
+          when_conditions,
+          else_node,
+          end_node,
+          start_position,
+          end_position,
+          errors
+        );
+      }
     }
 
     case CONTROL_TYPE_WHEN: {
-      return (AST_NODE_T*)
-        ast_erb_when_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_when_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_IN: {
-      return (AST_NODE_T*)
-        ast_erb_in_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_in_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_BEGIN: {
@@ -300,8 +436,9 @@ static AST_NODE_T* create_control_node(
     }
 
     case CONTROL_TYPE_ENSURE: {
-      return (AST_NODE_T*)
-        ast_erb_ensure_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_ensure_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
     case CONTROL_TYPE_UNLESS: {
@@ -375,34 +512,35 @@ static AST_NODE_T* create_control_node(
     }
 
     case CONTROL_TYPE_YIELD: {
-      return (AST_NODE_T*)
-        ast_erb_yield_node_init(tag_opening, content, tag_closing, start_position, end_position, errors);
+      return (
+        AST_NODE_T*
+      ) ast_erb_yield_node_init(tag_opening, content, tag_closing, start_position, end_position, errors);
     }
 
-    default: array_free(&errors); return NULL;
+    default: return NULL;
   }
 }
 
 static size_t process_control_structure(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* output_array,
+  hb_array_T* output_array,
   analyze_ruby_context_T* context,
   control_type_t initial_type
 ) {
-  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) array_get(array, index);
-  array_T* children = array_init(8);
+  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) hb_array_get(array, index);
+  hb_array_T* children = hb_array_init(8);
 
   index++;
 
   if (initial_type == CONTROL_TYPE_CASE || initial_type == CONTROL_TYPE_CASE_MATCH) {
-    array_T* when_conditions = array_init(8);
-    array_T* in_conditions = array_init(8);
-    array_T* non_when_non_in_children = array_init(8);
+    hb_array_T* when_conditions = hb_array_init(8);
+    hb_array_T* in_conditions = hb_array_init(8);
+    hb_array_T* non_when_non_in_children = hb_array_init(8);
 
-    while (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    while (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (!next_node) { break; }
 
@@ -413,17 +551,17 @@ static size_t process_control_structure(
         if (next_type == CONTROL_TYPE_WHEN || next_type == CONTROL_TYPE_IN) { break; }
       }
 
-      array_append(non_when_non_in_children, next_node);
+      hb_array_append(non_when_non_in_children, next_node);
       index++;
     }
 
-    while (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    while (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (!next_node) { break; }
 
       if (next_node->type != AST_ERB_CONTENT_NODE) {
-        array_append(non_when_non_in_children, next_node);
+        hb_array_append(non_when_non_in_children, next_node);
         index++;
         continue;
       }
@@ -432,167 +570,142 @@ static size_t process_control_structure(
       control_type_t next_type = detect_control_type(erb_content);
 
       if (next_type == CONTROL_TYPE_WHEN) {
-        array_T* when_statements = array_init(8);
+        hb_array_T* when_statements = hb_array_init(8);
         index++;
 
-        while (index < array_size(array)) {
-          AST_NODE_T* child = array_get(array, index);
-
-          if (!child) { break; }
-
-          if (child->type == AST_ERB_CONTENT_NODE) {
-            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-            control_type_t child_type = detect_control_type(child_erb);
+        index = process_block_children(node, array, index, when_statements, context, CONTROL_TYPE_WHEN);
 
-            if (child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE
-                || child_type == CONTROL_TYPE_END) {
-              break;
-            }
-          }
-
-          array_append(when_statements, child);
-          index++;
-        }
+        hb_array_T* when_errors = erb_content->base.errors;
+        erb_content->base.errors = NULL;
 
         AST_ERB_WHEN_NODE_T* when_node = ast_erb_when_node_init(
           erb_content->tag_opening,
           erb_content->content,
           erb_content->tag_closing,
           when_statements,
-          erb_content->tag_opening->location->start,
-          erb_content->tag_closing->location->end,
-          array_init(8)
+          erb_content->tag_opening->location.start,
+          erb_content->tag_closing->location.end,
+          when_errors
         );
 
-        array_append(when_conditions, (AST_NODE_T*) when_node);
+        ast_node_free((AST_NODE_T*) erb_content);
+
+        hb_array_append(when_conditions, (AST_NODE_T*) when_node);
 
         continue;
       } else if (next_type == CONTROL_TYPE_IN) {
-        array_T* in_statements = array_init(8);
+        hb_array_T* in_statements = hb_array_init(8);
         index++;
 
-        while (index < array_size(array)) {
-          AST_NODE_T* child = array_get(array, index);
-
-          if (!child) { break; }
+        index = process_block_children(node, array, index, in_statements, context, CONTROL_TYPE_IN);
 
-          if (child->type == AST_ERB_CONTENT_NODE) {
-            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-            control_type_t child_type = detect_control_type(child_erb);
-
-            if (child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE
-                || child_type == CONTROL_TYPE_END) {
-              break;
-            }
-          }
-
-          array_append(in_statements, child);
-          index++;
-        }
+        hb_array_T* in_errors = erb_content->base.errors;
+        erb_content->base.errors = NULL;
 
         AST_ERB_IN_NODE_T* in_node = ast_erb_in_node_init(
           erb_content->tag_opening,
           erb_content->content,
           erb_content->tag_closing,
           in_statements,
-          erb_content->tag_opening->location->start,
-          erb_content->tag_closing->location->end,
-          array_init(8)
+          erb_content->tag_opening->location.start,
+          erb_content->tag_closing->location.end,
+          in_errors
         );
 
-        array_append(in_conditions, (AST_NODE_T*) in_node);
+        ast_node_free((AST_NODE_T*) erb_content);
+
+        hb_array_append(in_conditions, (AST_NODE_T*) in_node);
 
         continue;
       } else if (next_type == CONTROL_TYPE_ELSE || next_type == CONTROL_TYPE_END) {
         break;
       } else {
-        array_append(non_when_non_in_children, next_node);
+        hb_array_append(non_when_non_in_children, next_node);
         index++;
       }
     }
 
     AST_ERB_ELSE_NODE_T* else_clause = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ELSE) {
-          array_T* else_children = array_init(8);
+          hb_array_T* else_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
+          index = process_block_children(node, array, index, else_children, context, initial_type);
 
-            if (!child) { break; }
-
-            if (child->type == AST_ERB_CONTENT_NODE) {
-              AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-              control_type_t child_type = detect_control_type(child_erb);
-
-              if (child_type == CONTROL_TYPE_END) { break; }
-            }
-
-            array_append(else_children, child);
-            index++;
-          }
+          hb_array_T* else_errors = next_erb->base.errors;
+          next_erb->base.errors = NULL;
 
           else_clause = ast_erb_else_node_init(
             next_erb->tag_opening,
             next_erb->content,
             next_erb->tag_closing,
             else_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
-            array_init(8)
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
+            else_errors
           );
+
+          ast_node_free((AST_NODE_T*) next_erb);
         }
       }
     }
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_end = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_end = hb_array_get(array, index);
 
       if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
 
         if (detect_control_type(end_erb) == CONTROL_TYPE_END) {
+          hb_array_T* end_errors = end_erb->base.errors;
+          end_erb->base.errors = NULL;
+
           end_node = ast_erb_end_node_init(
             end_erb->tag_opening,
             end_erb->content,
             end_erb->tag_closing,
-            end_erb->tag_opening->location->start,
-            end_erb->tag_closing->location->end,
-            end_erb->base.errors
+            end_erb->tag_opening->location.start,
+            end_erb->tag_closing->location.end,
+            end_errors
           );
 
+          ast_node_free((AST_NODE_T*) end_erb);
+
           index++;
         }
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (else_clause) {
-      end_position = else_clause->base.location->end;
-    } else if (array_size(when_conditions) > 0) {
-      AST_NODE_T* last_when = array_get(when_conditions, array_size(when_conditions) - 1);
-      end_position = last_when->location->end;
-    } else if (array_size(in_conditions) > 0) {
-      AST_NODE_T* last_in = array_get(in_conditions, array_size(in_conditions) - 1);
-      end_position = last_in->location->end;
+      end_position = else_clause->base.location.end;
+    } else if (hb_array_size(when_conditions) > 0) {
+      AST_NODE_T* last_when = hb_array_last(when_conditions);
+      end_position = last_when->location.end;
+    } else if (hb_array_size(in_conditions) > 0) {
+      AST_NODE_T* last_in = hb_array_last(in_conditions);
+      end_position = last_in->location.end;
     }
 
-    if (array_size(in_conditions) > 0) {
+    if (hb_array_size(in_conditions) > 0) {
+      hb_array_T* case_match_errors = erb_node->base.errors;
+      erb_node->base.errors = NULL;
+
       AST_ERB_CASE_MATCH_NODE_T* case_match_node = ast_erb_case_match_node_init(
         erb_node->tag_opening,
         erb_node->content,
@@ -603,13 +716,21 @@ static size_t process_control_structure(
         end_node,
         start_position,
         end_position,
-        array_init(8)
+        case_match_errors
       );
 
-      array_append(output_array, (AST_NODE_T*) case_match_node);
+      ast_node_free((AST_NODE_T*) erb_node);
+
+      hb_array_append(output_array, (AST_NODE_T*) case_match_node);
+      hb_array_free(&when_conditions);
+      hb_array_free(&children);
+
       return index;
     }
 
+    hb_array_T* case_errors = erb_node->base.errors;
+    erb_node->base.errors = NULL;
+
     AST_ERB_CASE_NODE_T* case_node = ast_erb_case_node_init(
       erb_node->tag_opening,
       erb_node->content,
@@ -620,10 +741,15 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      case_errors
     );
 
-    array_append(output_array, (AST_NODE_T*) case_node);
+    ast_node_free((AST_NODE_T*) erb_node);
+
+    hb_array_append(output_array, (AST_NODE_T*) case_node);
+    hb_array_free(&in_conditions);
+    hb_array_free(&children);
+
     return index;
   }
 
@@ -634,8 +760,8 @@ static size_t process_control_structure(
     AST_ERB_ELSE_NODE_T* else_clause = NULL;
     AST_ERB_ENSURE_NODE_T* ensure_clause = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -649,61 +775,52 @@ static size_t process_control_structure(
       }
     }
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ELSE) {
-          array_T* else_children = array_init(8);
+          hb_array_T* else_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
-
-            if (!child) { break; }
-
-            if (child->type == AST_ERB_CONTENT_NODE) {
-              AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
-              control_type_t child_type = detect_control_type(child_erb);
-
-              if (child_type == CONTROL_TYPE_ENSURE || child_type == CONTROL_TYPE_END) { break; }
-            }
+          index = process_block_children(node, array, index, else_children, context, initial_type);
 
-            array_append(else_children, child);
-            index++;
-          }
+          hb_array_T* else_errors = next_erb->base.errors;
+          next_erb->base.errors = NULL;
 
           else_clause = ast_erb_else_node_init(
             next_erb->tag_opening,
             next_erb->content,
             next_erb->tag_closing,
             else_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
-            array_init(8)
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
+            else_errors
           );
+
+          ast_node_free((AST_NODE_T*) next_erb);
         }
       }
     }
 
-    if (index < array_size(array)) {
-      AST_NODE_T* next_node = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(next_erb);
 
         if (next_type == CONTROL_TYPE_ENSURE) {
-          array_T* ensure_children = array_init(8);
+          hb_array_T* ensure_children = hb_array_init(8);
 
           index++;
 
-          while (index < array_size(array)) {
-            AST_NODE_T* child = array_get(array, index);
+          while (index < hb_array_size(array)) {
+            AST_NODE_T* child = hb_array_get(array, index);
 
             if (!child) { break; }
 
@@ -714,59 +831,72 @@ static size_t process_control_structure(
               if (child_type == CONTROL_TYPE_END) { break; }
             }
 
-            array_append(ensure_children, child);
+            hb_array_append(ensure_children, child);
             index++;
           }
 
+          hb_array_T* ensure_errors = next_erb->base.errors;
+          next_erb->base.errors = NULL;
+
           ensure_clause = ast_erb_ensure_node_init(
             next_erb->tag_opening,
             next_erb->content,
             next_erb->tag_closing,
             ensure_children,
-            next_erb->tag_opening->location->start,
-            next_erb->tag_closing->location->end,
-            array_init(8)
+            next_erb->tag_opening->location.start,
+            next_erb->tag_closing->location.end,
+            ensure_errors
           );
+
+          ast_node_free((AST_NODE_T*) next_erb);
         }
       }
     }
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_end = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_end = hb_array_get(array, index);
 
       if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
 
         if (detect_control_type(end_erb) == CONTROL_TYPE_END) {
+          hb_array_T* end_errors = end_erb->base.errors;
+          end_erb->base.errors = NULL;
+
           end_node = ast_erb_end_node_init(
             end_erb->tag_opening,
             end_erb->content,
             end_erb->tag_closing,
-            end_erb->tag_opening->location->start,
-            end_erb->tag_closing->location->end,
-            end_erb->base.errors
+            end_erb->tag_opening->location.start,
+            end_erb->tag_closing->location.end,
+            end_errors
           );
 
+          ast_node_free((AST_NODE_T*) end_erb);
+
           index++;
         }
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
+      end_position = end_node->base.location.end;
     } else if (ensure_clause) {
-      end_position = ensure_clause->base.location->end;
+      end_position = ensure_clause->base.location.end;
     } else if (else_clause) {
-      end_position = else_clause->base.location->end;
+      end_position = else_clause->base.location.end;
     } else if (rescue_clause) {
-      end_position = rescue_clause->base.location->end;
+      end_position = rescue_clause->base.location.end;
     }
 
+    hb_array_T* begin_errors = erb_node->base.errors;
+    erb_node->base.errors = NULL;
+
     AST_ERB_BEGIN_NODE_T* begin_node = ast_erb_begin_node_init(
       erb_node->tag_opening,
       erb_node->content,
@@ -778,10 +908,12 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      begin_errors
     );
 
-    array_append(output_array, (AST_NODE_T*) begin_node);
+    ast_node_free((AST_NODE_T*) erb_node);
+
+    hb_array_append(output_array, (AST_NODE_T*) begin_node);
     return index;
   }
 
@@ -790,38 +922,46 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array_size(array)) {
-      AST_NODE_T* potential_close = array_get(array, index);
+    if (index < hb_array_size(array)) {
+      AST_NODE_T* potential_close = hb_array_get(array, index);
 
       if (potential_close && potential_close->type == AST_ERB_CONTENT_NODE) {
         AST_ERB_CONTENT_NODE_T* close_erb = (AST_ERB_CONTENT_NODE_T*) potential_close;
         control_type_t close_type = detect_control_type(close_erb);
 
         if (close_type == CONTROL_TYPE_BLOCK_CLOSE || close_type == CONTROL_TYPE_END) {
+          hb_array_T* end_errors = close_erb->base.errors;
+          close_erb->base.errors = NULL;
+
           end_node = ast_erb_end_node_init(
             close_erb->tag_opening,
             close_erb->content,
             close_erb->tag_closing,
-            close_erb->tag_opening->location->start,
-            close_erb->tag_closing->location->end,
-            close_erb->base.errors
+            close_erb->tag_opening->location.start,
+            close_erb->tag_closing->location.end,
+            end_errors
           );
 
+          ast_node_free((AST_NODE_T*) close_erb);
+
           index++;
         }
       }
     }
 
-    position_T* start_position = erb_node->tag_opening->location->start;
-    position_T* end_position = erb_node->tag_closing->location->end;
+    position_T start_position = erb_node->tag_opening->location.start;
+    position_T end_position = erb_node->tag_closing->location.end;
 
     if (end_node) {
-      end_position = end_node->base.location->end;
-    } else if (children && array_size(children) > 0) {
-      AST_NODE_T* last_child = array_get(children, array_size(children) - 1);
-      end_position = last_child->location->end;
+      end_position = end_node->base.location.end;
+    } else if (children && hb_array_size(children) > 0) {
+      AST_NODE_T* last_child = hb_array_last(children);
+      end_position = last_child->location.end;
     }
 
+    hb_array_T* block_errors = erb_node->base.errors;
+    erb_node->base.errors = NULL;
+
     AST_ERB_BLOCK_NODE_T* block_node = ast_erb_block_node_init(
       erb_node->tag_opening,
       erb_node->content,
@@ -830,10 +970,12 @@ static size_t process_control_structure(
       end_node,
       start_position,
       end_position,
-      array_init(8)
+      block_errors
     );
 
-    array_append(output_array, (AST_NODE_T*) block_node);
+    ast_node_free((AST_NODE_T*) erb_node);
+
+    hb_array_append(output_array, (AST_NODE_T*) block_node);
     return index;
   }
 
@@ -842,8 +984,8 @@ static size_t process_control_structure(
   AST_NODE_T* subsequent = NULL;
   AST_ERB_END_NODE_T* end_node = NULL;
 
-  if (index < array_size(array)) {
-    AST_NODE_T* next_node = array_get(array, index);
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* next_node = hb_array_get(array, index);
 
     if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -855,22 +997,27 @@ static size_t process_control_structure(
     }
   }
 
-  if (index < array_size(array)) {
-    AST_NODE_T* potential_end = array_get(array, index);
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* potential_end = hb_array_get(array, index);
 
     if (potential_end && potential_end->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* end_erb = (AST_ERB_CONTENT_NODE_T*) potential_end;
 
       if (detect_control_type(end_erb) == CONTROL_TYPE_END) {
+        hb_array_T* end_errors = end_erb->base.errors;
+        end_erb->base.errors = NULL;
+
         end_node = ast_erb_end_node_init(
           end_erb->tag_opening,
           end_erb->content,
           end_erb->tag_closing,
-          end_erb->tag_opening->location->start,
-          end_erb->tag_closing->location->end,
-          end_erb->base.errors
+          end_erb->tag_opening->location.start,
+          end_erb->tag_closing->location.end,
+          end_errors
         );
 
+        ast_node_free((AST_NODE_T*) end_erb);
+
         index++;
       }
     }
@@ -878,22 +1025,27 @@ static size_t process_control_structure(
 
   AST_NODE_T* control_node = create_control_node(erb_node, children, subsequent, end_node, initial_type);
 
-  if (control_node) { array_append(output_array, control_node); }
+  if (control_node) {
+    ast_node_free((AST_NODE_T*) erb_node);
+    hb_array_append(output_array, control_node);
+  } else {
+    hb_array_free(&children);
+  }
 
   return index;
 }
 
 static size_t process_subsequent_block(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
   AST_NODE_T** subsequent_out,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
-  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) array_get(array, index);
+  AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) hb_array_get(array, index);
   control_type_t type = detect_control_type(erb_node);
-  array_T* children = array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   index++;
 
@@ -901,8 +1053,14 @@ static size_t process_subsequent_block(
 
   AST_NODE_T* subsequent_node = create_control_node(erb_node, children, NULL, NULL, type);
 
-  if (index < array_size(array)) {
-    AST_NODE_T* next_node = array_get(array, index);
+  if (subsequent_node) {
+    ast_node_free((AST_NODE_T*) erb_node);
+  } else {
+    hb_array_free(&children);
+  }
+
+  if (index < hb_array_size(array)) {
+    AST_NODE_T* next_node = hb_array_get(array, index);
 
     if (next_node && next_node->type == AST_ERB_CONTENT_NODE) {
       AST_ERB_CONTENT_NODE_T* next_erb = (AST_ERB_CONTENT_NODE_T*) next_node;
@@ -953,19 +1111,19 @@ static size_t process_subsequent_block(
 
 static size_t process_block_children(
   AST_NODE_T* node,
-  array_T* array,
+  hb_array_T* array,
   size_t index,
-  array_T* children_array,
+  hb_array_T* children_array,
   analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
-  while (index < array_size(array)) {
-    AST_NODE_T* child = array_get(array, index);
+  while (index < hb_array_size(array)) {
+    AST_NODE_T* child = hb_array_get(array, index);
 
     if (!child) { break; }
 
     if (child->type != AST_ERB_CONTENT_NODE) {
-      array_append(children_array, child);
+      hb_array_append(children_array, child);
       index++;
       continue;
     }
@@ -978,35 +1136,35 @@ static size_t process_block_children(
     if (child_type == CONTROL_TYPE_IF || child_type == CONTROL_TYPE_CASE || child_type == CONTROL_TYPE_CASE_MATCH
         || child_type == CONTROL_TYPE_BEGIN || child_type == CONTROL_TYPE_UNLESS || child_type == CONTROL_TYPE_WHILE
         || child_type == CONTROL_TYPE_UNTIL || child_type == CONTROL_TYPE_FOR || child_type == CONTROL_TYPE_BLOCK) {
-      array_T* temp_array = array_init(1);
+      hb_array_T* temp_array = hb_array_init(1);
       size_t new_index = process_control_structure(node, array, index, temp_array, context, child_type);
 
-      if (array_size(temp_array) > 0) { array_append(children_array, array_get(temp_array, 0)); }
+      if (hb_array_size(temp_array) > 0) { hb_array_append(children_array, hb_array_first(temp_array)); }
 
-      array_free(&temp_array);
+      hb_array_free(&temp_array);
 
       index = new_index;
       continue;
     }
 
-    array_append(children_array, child);
+    hb_array_append(children_array, child);
     index++;
   }
 
   return index;
 }
 
-static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_ruby_context_T* context) {
-  array_T* new_array = array_init(array_size(array));
+hb_array_T* rewrite_node_array(AST_NODE_T* node, hb_array_T* array, analyze_ruby_context_T* context) {
+  hb_array_T* new_array = hb_array_init(hb_array_size(array));
   size_t index = 0;
 
-  while (index < array_size(array)) {
-    AST_NODE_T* item = array_get(array, index);
+  while (index < hb_array_size(array)) {
+    AST_NODE_T* item = hb_array_get(array, index);
 
     if (!item) { break; }
 
     if (item->type != AST_ERB_CONTENT_NODE) {
-      array_append(new_array, item);
+      hb_array_append(new_array, item);
       index++;
       continue;
     }
@@ -1028,12 +1186,13 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
         continue;
 
       case CONTROL_TYPE_YIELD: {
-        AST_NODE_T* yield_node = create_control_node(erb_node, array_init(8), NULL, NULL, type);
+        AST_NODE_T* yield_node = create_control_node(erb_node, NULL, NULL, NULL, type);
 
         if (yield_node) {
-          array_append(new_array, yield_node);
+          ast_node_free((AST_NODE_T*) erb_node);
+          hb_array_append(new_array, yield_node);
         } else {
-          array_append(new_array, item);
+          hb_array_append(new_array, item);
         }
 
         index++;
@@ -1041,7 +1200,7 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
       }
 
       default:
-        array_append(new_array, item);
+        hb_array_append(new_array, item);
         index++;
         break;
     }
@@ -1050,41 +1209,178 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
   return new_array;
 }
 
-static bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
-  analyze_ruby_context_T* context = (analyze_ruby_context_T*) data;
-  context->parent = (AST_NODE_T*) node;
+static 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_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);
+
+  bool is_begin_node = (node->type == AST_ERB_BEGIN_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;
+      }
+
+      const char* keyword = NULL;
+
+      if (context->loop_depth == 0) {
+        if (has_error_message(analyzed, "Invalid break")) {
+          keyword = "`<% break %>`";
+        } else if (has_error_message(analyzed, "Invalid next")) {
+          keyword = "`<% next %>`";
+        } else if (has_error_message(analyzed, "Invalid redo")) {
+          keyword = "`<% 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 = "`<% 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 (keyword == NULL) { keyword = erb_keyword_from_analyzed_ruby(analyzed); }
+
+      if (keyword != NULL && !token_value_empty(content_node->tag_closing)) {
+        append_erb_control_flow_scope_error(keyword, node->location.start, node->location.end, 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); }
+
+    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;
+          const char* 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,
+              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 (node->type == AST_DOCUMENT_NODE) {
-    AST_DOCUMENT_NODE_T* document_node = (AST_DOCUMENT_NODE_T*) node;
-    array_T* old_array = document_node->children;
-    document_node->children = rewrite_node_array((AST_NODE_T*) node, document_node->children, context);
-    array_free(&old_array);
+        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_HTML_ELEMENT_NODE) {
-    AST_HTML_ELEMENT_NODE_T* element_node = (AST_HTML_ELEMENT_NODE_T*) node;
-    array_T* old_array = element_node->body;
-    element_node->body = rewrite_node_array((AST_NODE_T*) node, element_node->body, context);
-    array_free(&old_array);
+  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_HTML_OPEN_TAG_NODE) {
-    AST_HTML_OPEN_TAG_NODE_T* open_tag = (AST_HTML_OPEN_TAG_NODE_T*) node;
-    array_T* old_array = open_tag->children;
-    open_tag->children = rewrite_node_array((AST_NODE_T*) node, open_tag->children, context);
-    array_free(&old_array);
+  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);
+
+    if (is_loop_node) { context->loop_depth--; }
+    if (is_begin_node) { context->rescue_depth--; }
+
+    return false;
   }
 
-  if (node->type == AST_HTML_ATTRIBUTE_VALUE_NODE) {
-    AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node = (AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
-    array_T* old_array = value_node->children;
-    value_node->children = rewrite_node_array((AST_NODE_T*) node, value_node->children, context);
-    array_free(&old_array);
+  if (node->type == AST_ERB_IF_NODE) {
+    if (is_loop_node) { context->loop_depth--; }
+    if (is_begin_node) { context->rescue_depth--; }
+
+    return false;
   }
 
-  herb_visit_child_nodes(node, transform_erb_nodes, data);
+  bool result = true;
 
-  return false;
+  if (is_loop_node) { context->loop_depth--; }
+  if (is_begin_node) { context->rescue_depth--; }
+
+  return result;
 }
 
 void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source) {
@@ -1093,19 +1389,31 @@ void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source)
   analyze_ruby_context_T* context = malloc(sizeof(analyze_ruby_context_T));
   context->document = document;
   context->parent = NULL;
-  context->ruby_context_stack = array_init(8);
+  context->ruby_context_stack = hb_array_init(8);
 
   herb_visit_node((AST_NODE_T*) document, transform_erb_nodes, context);
 
+  invalid_erb_context_T* invalid_context = malloc(sizeof(invalid_erb_context_T));
+  invalid_context->loop_depth = 0;
+  invalid_context->rescue_depth = 0;
+
+  herb_visit_node((AST_NODE_T*) document, detect_invalid_erb_structures, invalid_context);
+
   herb_analyze_parse_errors(document, source);
 
-  array_free(&context->ruby_context_stack);
+  herb_parser_match_html_tags_post_analyze(document);
+
+  hb_array_free(&context->ruby_context_stack);
+
   free(context);
+  free(invalid_context);
 }
 
 void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source) {
   char* extracted_ruby = herb_extract_ruby_with_semicolons(source);
 
+  if (!extracted_ruby) { return; }
+
   pm_parser_t parser;
   pm_options_t options = { 0, .partial_script = true };
   pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), &options);
@@ -1116,7 +1424,7 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
        error = (const pm_diagnostic_t*) error->node.next) {
 
     RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser);
-    array_append(document->base.errors, parse_error);
+    hb_array_append(document->base.errors, parse_error);
   }
 
   pm_node_destroy(&parser, root);