herb 0.8.6-x86_64-linux-gnu → 0.8.8-x86_64-linux-gnu

data/src/analyze.c

@@ -43,6 +43,7 @@ static analyzed_ruby_T* herb_analyze_ruby(hb_string_T source) {
   search_rescue_nodes(analyzed);
   search_ensure_nodes(analyzed);
   search_yield_nodes(analyzed->root, analyzed);
+  search_then_keywords(analyzed->root, analyzed);
   search_block_closing_nodes(analyzed);
 
   if (!analyzed->valid) { pm_visit_node(analyzed->root, search_unclosed_control_flows, analyzed); }
@@ -112,6 +113,14 @@ typedef struct {
   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; }
 
@@ -194,14 +203,12 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
 
       if (call->block != NULL && call->block->type == PM_BLOCK_NODE) {
         pm_block_node_t* block_node = (pm_block_node_t*) call->block;
-        size_t opening_length = block_node->opening_loc.end - block_node->opening_loc.start;
-        bool has_do_opening =
-          opening_length == 2 && block_node->opening_loc.start[0] == 'd' && block_node->opening_loc.start[1] == 'o';
-        bool has_brace_opening = opening_length == 1 && block_node->opening_loc.start[0] == '{';
-        bool has_closing_location = block_node->closing_loc.start != NULL && block_node->closing_loc.end != NULL
-                                 && (block_node->closing_loc.end - block_node->closing_loc.start) > 0;
-
-        if (has_do_opening || (has_brace_opening && !has_closing_location)) {
+
+        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);
         }
@@ -221,7 +228,17 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
   }
 
   if (keyword_offset != UINT32_MAX) {
-    if (!result->found || keyword_offset < result->offset) {
+    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;
@@ -308,7 +325,7 @@ static AST_NODE_T* create_control_node(
 
   if (end_node) {
     end_position = end_node->base.location.end;
-  } else if (children && children->size > 0) {
+  } else if (hb_array_size(children) > 0) {
     AST_NODE_T* last_child = hb_array_last(children);
     end_position = last_child->location.end;
   } else if (subsequent) {
@@ -319,6 +336,34 @@ static AST_NODE_T* create_control_node(
   token_T* content = erb_node->content;
   token_T* tag_closing = erb_node->tag_closing;
 
+  location_T* then_keyword = NULL;
+
+  if (control_type == CONTROL_TYPE_IF || control_type == CONTROL_TYPE_ELSIF || control_type == CONTROL_TYPE_UNLESS
+      || control_type == CONTROL_TYPE_WHEN || control_type == CONTROL_TYPE_IN) {
+    const char* source = content ? content->value : NULL;
+
+    if (control_type == CONTROL_TYPE_WHEN || control_type == CONTROL_TYPE_IN) {
+      if (source != NULL && strstr(source, "then") != NULL) {
+        then_keyword = get_then_keyword_location_wrapped(source, control_type == CONTROL_TYPE_IN);
+      }
+    } else if (control_type == CONTROL_TYPE_ELSIF) {
+      if (source != NULL && strstr(source, "then") != NULL) {
+        then_keyword = get_then_keyword_location_elsif_wrapped(source);
+      }
+    } else {
+      then_keyword = get_then_keyword_location(erb_node->analyzed_ruby, source);
+    }
+
+    if (then_keyword != NULL && content != NULL) {
+      position_T content_start = content->location.start;
+
+      then_keyword->start.line = content_start.line + then_keyword->start.line - 1;
+      then_keyword->start.column = content_start.column + then_keyword->start.column;
+      then_keyword->end.line = content_start.line + then_keyword->end.line - 1;
+      then_keyword->end.column = content_start.column + then_keyword->end.column;
+    }
+  }
+
   switch (control_type) {
     case CONTROL_TYPE_IF:
     case CONTROL_TYPE_ELSIF: {
@@ -326,6 +371,7 @@ static AST_NODE_T* create_control_node(
         tag_opening,
         content,
         tag_closing,
+        then_keyword,
         children,
         subsequent,
         end_node,
@@ -350,7 +396,7 @@ static AST_NODE_T* create_control_node(
       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 < children->size; i++) {
+      for (size_t i = 0; i < hb_array_size(children); i++) {
         AST_NODE_T* child = hb_array_get(children, i);
 
         if (child && child->type == AST_ERB_WHEN_NODE) {
@@ -364,7 +410,7 @@ static AST_NODE_T* create_control_node(
 
       hb_array_free(&children);
 
-      if (in_conditions->size > 0) {
+      if (hb_array_size(in_conditions) > 0) {
         hb_array_free(&when_conditions);
 
         return (AST_NODE_T*) ast_erb_case_match_node_init(
@@ -398,15 +444,29 @@ static AST_NODE_T* create_control_node(
     }
 
     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,
+        then_keyword,
+        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,
+        then_keyword,
+        children,
+        start_position,
+        end_position,
+        errors
+      );
     }
 
     case CONTROL_TYPE_BEGIN: {
@@ -471,6 +531,7 @@ static AST_NODE_T* create_control_node(
         tag_opening,
         content,
         tag_closing,
+        then_keyword,
         children,
         else_clause,
         end_node,
@@ -560,7 +621,7 @@ static size_t process_control_structure(
     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) {
+    while (index < hb_array_size(array)) {
       AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (!next_node) { break; }
@@ -576,7 +637,7 @@ static size_t process_control_structure(
       index++;
     }
 
-    while (index < array->size) {
+    while (index < hb_array_size(array)) {
       AST_NODE_T* next_node = hb_array_get(array, index);
 
       if (!next_node) { break; }
@@ -599,10 +660,27 @@ static size_t process_control_structure(
         hb_array_T* when_errors = erb_content->base.errors;
         erb_content->base.errors = NULL;
 
+        location_T* then_keyword = NULL;
+        const char* source = erb_content->content ? erb_content->content->value : NULL;
+
+        if (source != NULL && strstr(source, "then") != NULL) {
+          then_keyword = get_then_keyword_location_wrapped(source, false);
+
+          if (then_keyword != NULL && erb_content->content != NULL) {
+            position_T content_start = erb_content->content->location.start;
+
+            then_keyword->start.line = content_start.line + then_keyword->start.line - 1;
+            then_keyword->start.column = content_start.column + then_keyword->start.column;
+            then_keyword->end.line = content_start.line + then_keyword->end.line - 1;
+            then_keyword->end.column = content_start.column + then_keyword->end.column;
+          }
+        }
+
         AST_ERB_WHEN_NODE_T* when_node = ast_erb_when_node_init(
           erb_content->tag_opening,
           erb_content->content,
           erb_content->tag_closing,
+          then_keyword,
           when_statements,
           erb_content->tag_opening->location.start,
           erb_content->tag_closing->location.end,
@@ -623,10 +701,27 @@ static size_t process_control_structure(
         hb_array_T* in_errors = erb_content->base.errors;
         erb_content->base.errors = NULL;
 
+        location_T* in_then_keyword = NULL;
+        const char* in_source = erb_content->content ? erb_content->content->value : NULL;
+
+        if (in_source != NULL && strstr(in_source, "then") != NULL) {
+          in_then_keyword = get_then_keyword_location_wrapped(in_source, true);
+
+          if (in_then_keyword != NULL && erb_content->content != NULL) {
+            position_T content_start = erb_content->content->location.start;
+
+            in_then_keyword->start.line = content_start.line + in_then_keyword->start.line - 1;
+            in_then_keyword->start.column = content_start.column + in_then_keyword->start.column;
+            in_then_keyword->end.line = content_start.line + in_then_keyword->end.line - 1;
+            in_then_keyword->end.column = content_start.column + in_then_keyword->end.column;
+          }
+        }
+
         AST_ERB_IN_NODE_T* in_node = ast_erb_in_node_init(
           erb_content->tag_opening,
           erb_content->content,
           erb_content->tag_closing,
+          in_then_keyword,
           in_statements,
           erb_content->tag_opening->location.start,
           erb_content->tag_closing->location.end,
@@ -648,7 +743,7 @@ static size_t process_control_structure(
 
     AST_ERB_ELSE_NODE_T* else_clause = NULL;
 
-    if (index < array->size) {
+    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) {
@@ -682,7 +777,7 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array->size) {
+    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) {
@@ -715,15 +810,15 @@ static size_t process_control_structure(
       end_position = end_node->base.location.end;
     } else if (else_clause) {
       end_position = else_clause->base.location.end;
-    } else if (when_conditions->size > 0) {
+    } 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 (in_conditions->size > 0) {
+    } 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 (in_conditions->size > 0) {
+    if (hb_array_size(in_conditions) > 0) {
       hb_array_T* case_match_errors = erb_node->base.errors;
       erb_node->base.errors = NULL;
 
@@ -781,7 +876,7 @@ 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) {
+    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) {
@@ -796,7 +891,7 @@ static size_t process_control_structure(
       }
     }
 
-    if (index < array->size) {
+    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) {
@@ -828,7 +923,7 @@ static size_t process_control_structure(
       }
     }
 
-    if (index < array->size) {
+    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) {
@@ -840,7 +935,7 @@ static size_t process_control_structure(
 
           index++;
 
-          while (index < array->size) {
+          while (index < hb_array_size(array)) {
             AST_NODE_T* child = hb_array_get(array, index);
 
             if (!child) { break; }
@@ -876,7 +971,7 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array->size) {
+    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) {
@@ -943,7 +1038,7 @@ static size_t process_control_structure(
 
     AST_ERB_END_NODE_T* end_node = NULL;
 
-    if (index < array->size) {
+    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) {
@@ -975,7 +1070,7 @@ static size_t process_control_structure(
 
     if (end_node) {
       end_position = end_node->base.location.end;
-    } else if (children && children->size > 0) {
+    } else if (hb_array_size(children) > 0) {
       AST_NODE_T* last_child = hb_array_last(children);
       end_position = last_child->location.end;
     }
@@ -1005,7 +1100,7 @@ static size_t process_control_structure(
   AST_NODE_T* subsequent = NULL;
   AST_ERB_END_NODE_T* end_node = NULL;
 
-  if (index < array->size) {
+  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) {
@@ -1018,7 +1113,7 @@ static size_t process_control_structure(
     }
   }
 
-  if (index < array->size) {
+  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) {
@@ -1080,7 +1175,7 @@ static size_t process_subsequent_block(
     hb_array_free(&children);
   }
 
-  if (index < array->size) {
+  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) {
@@ -1138,7 +1233,7 @@ static size_t process_block_children(
   analyze_ruby_context_T* context,
   control_type_t parent_type
 ) {
-  while (index < array->size) {
+  while (index < hb_array_size(array)) {
     AST_NODE_T* child = hb_array_get(array, index);
 
     if (!child) { break; }
@@ -1160,7 +1255,7 @@ static size_t process_block_children(
       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 (temp_array->size > 0) { hb_array_append(children_array, hb_array_first(temp_array)); }
+      if (hb_array_size(temp_array) > 0) { hb_array_append(children_array, hb_array_first(temp_array)); }
 
       hb_array_free(&temp_array);
 
@@ -1176,10 +1271,10 @@ static size_t process_block_children(
 }
 
 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(array->size);
+  hb_array_T* new_array = hb_array_init(hb_array_size(array));
   size_t index = 0;
 
-  while (index < array->size) {
+  while (index < hb_array_size(array)) {
     AST_NODE_T* item = hb_array_get(array, index);
 
     if (!item) { break; }
@@ -1314,7 +1409,7 @@ static bool detect_invalid_erb_structures(const AST_NODE_T* node, void* data) {
     if (if_node->end_node == NULL) { check_erb_node_for_missing_end(node); }
 
     if (if_node->statements != NULL) {
-      for (size_t i = 0; i < if_node->statements->size; i++) {
+      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); }
@@ -1346,7 +1441,7 @@ static bool detect_invalid_erb_structures(const AST_NODE_T* node, void* data) {
         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 < elsif_node->statements->size; i++) {
+          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); }
@@ -1358,7 +1453,7 @@ static bool detect_invalid_erb_structures(const AST_NODE_T* node, void* data) {
         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 < else_node->statements->size; i++) {
+          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); }

data/src/analyze_helpers.c

@@ -76,6 +76,10 @@ bool has_yield_node(analyzed_ruby_T* analyzed) {
   return analyzed->yield_node_count > 0;
 }
 
+bool has_then_keyword(analyzed_ruby_T* analyzed) {
+  return 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;
        error = (const pm_diagnostic_t*) error->node.next) {
@@ -102,13 +106,13 @@ bool search_if_nodes(const pm_node_t* node, void* data) {
   return false;
 }
 
-static bool is_do_block(pm_location_t opening_location) {
+bool is_do_block(pm_location_t opening_location) {
   size_t length = opening_location.end - opening_location.start;
 
   return length == 2 && opening_location.start[0] == 'd' && opening_location.start[1] == 'o';
 }
 
-static bool is_brace_block(pm_location_t opening_location) {
+bool is_brace_block(pm_location_t opening_location) {
   size_t length = opening_location.end - opening_location.start;
 
   return length == 1 && opening_location.start[0] == '{';
@@ -118,6 +122,32 @@ static bool has_location(pm_location_t location) {
   return location.start != NULL && location.end != NULL && (location.end - location.start) > 0;
 }
 
+static bool is_end_keyword(pm_location_t location) {
+  if (location.start == NULL || location.end == NULL) { return false; }
+
+  size_t length = location.end - location.start;
+
+  return length == 3 && location.start[0] == 'e' && location.start[1] == 'n' && location.start[2] == 'd';
+}
+
+bool is_closing_brace(pm_location_t location) {
+  if (location.start == NULL || location.end == NULL) { return false; }
+
+  size_t length = location.end - location.start;
+
+  return length == 1 && location.start[0] == '}';
+}
+
+bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc) {
+  if (is_do_block(opening_loc)) {
+    return is_end_keyword(closing_loc);
+  } else if (is_brace_block(opening_loc)) {
+    return is_closing_brace(closing_loc);
+  }
+
+  return false;
+}
+
 bool search_block_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
@@ -125,7 +155,7 @@ bool search_block_nodes(const pm_node_t* node, void* data) {
     pm_block_node_t* block_node = (pm_block_node_t*) node;
 
     bool has_opening = is_do_block(block_node->opening_loc) || is_brace_block(block_node->opening_loc);
-    bool is_unclosed = !has_location(block_node->closing_loc);
+    bool is_unclosed = !has_valid_block_closing(block_node->opening_loc, block_node->closing_loc);
 
     if (has_opening && is_unclosed) { analyzed->block_node_count++; }
   }
@@ -299,6 +329,42 @@ bool search_yield_nodes(const pm_node_t* node, void* data) {
   return false;
 }
 
+bool search_then_keywords(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  switch (node->type) {
+    case PM_IF_NODE: {
+      const pm_if_node_t* if_node = (const pm_if_node_t*) node;
+      if (if_node->then_keyword_loc.start != NULL && if_node->then_keyword_loc.end != NULL) {
+        analyzed->then_keyword_count++;
+      }
+      break;
+    }
+
+    case PM_UNLESS_NODE: {
+      const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
+      if (unless_node->then_keyword_loc.start != NULL && unless_node->then_keyword_loc.end != NULL) {
+        analyzed->then_keyword_count++;
+      }
+      break;
+    }
+
+    case PM_WHEN_NODE: {
+      const pm_when_node_t* when_node = (const pm_when_node_t*) node;
+      if (when_node->then_keyword_loc.start != NULL && when_node->then_keyword_loc.end != NULL) {
+        analyzed->then_keyword_count++;
+      }
+      break;
+    }
+
+    default: break;
+  }
+
+  pm_visit_child_nodes(node, search_then_keywords, analyzed);
+
+  return false;
+}
+
 static bool is_postfix_conditional(const pm_statements_node_t* statements, pm_location_t keyword_location) {
   if (statements == NULL) { return false; }
 
@@ -314,7 +380,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
     case PM_IF_NODE: {
       const pm_if_node_t* if_node = (const pm_if_node_t*) node;
 
-      if (has_location(if_node->if_keyword_loc) && !has_location(if_node->end_keyword_loc)) {
+      if (has_location(if_node->if_keyword_loc) && !is_end_keyword(if_node->end_keyword_loc)) {
         if (!is_postfix_conditional(if_node->statements, if_node->if_keyword_loc)) {
           analyzed->unclosed_control_flow_count++;
         }
@@ -326,7 +392,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
     case PM_UNLESS_NODE: {
       const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
 
-      if (has_location(unless_node->keyword_loc) && !has_location(unless_node->end_keyword_loc)) {
+      if (has_location(unless_node->keyword_loc) && !is_end_keyword(unless_node->end_keyword_loc)) {
         if (!is_postfix_conditional(unless_node->statements, unless_node->keyword_loc)) {
           analyzed->unclosed_control_flow_count++;
         }
@@ -338,7 +404,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
     case PM_CASE_NODE: {
       const pm_case_node_t* case_node = (const pm_case_node_t*) node;
 
-      if (has_location(case_node->case_keyword_loc) && !has_location(case_node->end_keyword_loc)) {
+      if (has_location(case_node->case_keyword_loc) && !is_end_keyword(case_node->end_keyword_loc)) {
         analyzed->unclosed_control_flow_count++;
       }
 
@@ -348,7 +414,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
     case PM_CASE_MATCH_NODE: {
       const pm_case_match_node_t* case_match_node = (const pm_case_match_node_t*) node;
 
-      if (has_location(case_match_node->case_keyword_loc) && !has_location(case_match_node->end_keyword_loc)) {
+      if (has_location(case_match_node->case_keyword_loc) && !is_end_keyword(case_match_node->end_keyword_loc)) {
         analyzed->unclosed_control_flow_count++;
       }
 
@@ -358,7 +424,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
     case PM_WHILE_NODE: {
       const pm_while_node_t* while_node = (const pm_while_node_t*) node;
 
-      if (has_location(while_node->keyword_loc) && !has_location(while_node->closing_loc)) {
+      if (has_location(while_node->keyword_loc) && !is_end_keyword(while_node->closing_loc)) {
         analyzed->unclosed_control_flow_count++;
       }
 
@@ -368,7 +434,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
     case PM_UNTIL_NODE: {
       const pm_until_node_t* until_node = (const pm_until_node_t*) node;
 
-      if (has_location(until_node->keyword_loc) && !has_location(until_node->closing_loc)) {
+      if (has_location(until_node->keyword_loc) && !is_end_keyword(until_node->closing_loc)) {
         analyzed->unclosed_control_flow_count++;
       }
 
@@ -378,7 +444,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
     case PM_FOR_NODE: {
       const pm_for_node_t* for_node = (const pm_for_node_t*) node;
 
-      if (has_location(for_node->for_keyword_loc) && !has_location(for_node->end_keyword_loc)) {
+      if (has_location(for_node->for_keyword_loc) && !is_end_keyword(for_node->end_keyword_loc)) {
         analyzed->unclosed_control_flow_count++;
       }
 
@@ -388,7 +454,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
     case PM_BEGIN_NODE: {
       const pm_begin_node_t* begin_node = (const pm_begin_node_t*) node;
 
-      if (has_location(begin_node->begin_keyword_loc) && !has_location(begin_node->end_keyword_loc)) {
+      if (has_location(begin_node->begin_keyword_loc) && !is_end_keyword(begin_node->end_keyword_loc)) {
         analyzed->unclosed_control_flow_count++;
       }
 
@@ -399,7 +465,9 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
       const pm_block_node_t* block_node = (const pm_block_node_t*) node;
       bool has_opening = is_do_block(block_node->opening_loc) || is_brace_block(block_node->opening_loc);
 
-      if (has_opening && !has_location(block_node->closing_loc)) { analyzed->unclosed_control_flow_count++; }
+      if (has_opening && !has_valid_block_closing(block_node->opening_loc, block_node->closing_loc)) {
+        analyzed->unclosed_control_flow_count++;
+      }
       break;
     }
 

data/src/analyzed_ruby.c

@@ -30,6 +30,7 @@ analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
   analyzed->ensure_node_count = 0;
   analyzed->unless_node_count = 0;
   analyzed->yield_node_count = 0;
+  analyzed->then_keyword_count = 0;
   analyzed->unclosed_control_flow_count = 0;
 
   return analyzed;

data/src/ast_node.c

@@ -43,7 +43,7 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node) {
 }
 
 size_t ast_node_errors_count(const AST_NODE_T* node) {
-  return node->errors->size;
+  return hb_array_size(node->errors);
 }
 
 hb_array_T* ast_node_errors(const AST_NODE_T* node) {