herb 0.8.7 → 0.8.8

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;
@@ -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,
@@ -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,
@@ -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,

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_nodes.c

@@ -220,7 +220,7 @@ AST_ERB_ELSE_NODE_T* ast_erb_else_node_init(token_T* tag_opening, token_T* conte
   return erb_else_node;
 }
 
-AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_NODE_STRUCT* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors) {
+AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, struct AST_NODE_STRUCT* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors) {
   AST_ERB_IF_NODE_T* erb_if_node = malloc(sizeof(AST_ERB_IF_NODE_T));
 
   ast_node_init(&erb_if_node->base, AST_ERB_IF_NODE, start_position, end_position, errors);
@@ -228,6 +228,7 @@ AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content,
   erb_if_node->tag_opening = token_copy(tag_opening);
   erb_if_node->content = token_copy(content);
   erb_if_node->tag_closing = token_copy(tag_closing);
+  erb_if_node->then_keyword = then_keyword;
   erb_if_node->statements = statements;
   erb_if_node->subsequent = subsequent;
   erb_if_node->end_node = end_node;
@@ -249,7 +250,7 @@ AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* con
   return erb_block_node;
 }
 
-AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors) {
+AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors) {
   AST_ERB_WHEN_NODE_T* erb_when_node = malloc(sizeof(AST_ERB_WHEN_NODE_T));
 
   ast_node_init(&erb_when_node->base, AST_ERB_WHEN_NODE, start_position, end_position, errors);
@@ -257,6 +258,7 @@ AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* conte
   erb_when_node->tag_opening = token_copy(tag_opening);
   erb_when_node->content = token_copy(content);
   erb_when_node->tag_closing = token_copy(tag_closing);
+  erb_when_node->then_keyword = then_keyword;
   erb_when_node->statements = statements;
 
   return erb_when_node;
@@ -380,7 +382,7 @@ AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* con
   return erb_begin_node;
 }
 
-AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors) {
+AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T start_position, position_T end_position, hb_array_T* errors) {
   AST_ERB_UNLESS_NODE_T* erb_unless_node = malloc(sizeof(AST_ERB_UNLESS_NODE_T));
 
   ast_node_init(&erb_unless_node->base, AST_ERB_UNLESS_NODE, start_position, end_position, errors);
@@ -388,6 +390,7 @@ AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* c
   erb_unless_node->tag_opening = token_copy(tag_opening);
   erb_unless_node->content = token_copy(content);
   erb_unless_node->tag_closing = token_copy(tag_closing);
+  erb_unless_node->then_keyword = then_keyword;
   erb_unless_node->statements = statements;
   erb_unless_node->else_clause = else_clause;
   erb_unless_node->end_node = end_node;
@@ -407,7 +410,7 @@ AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* con
   return erb_yield_node;
 }
 
-AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors) {
+AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, location_T* then_keyword, hb_array_T* statements, position_T start_position, position_T end_position, hb_array_T* errors) {
   AST_ERB_IN_NODE_T* erb_in_node = malloc(sizeof(AST_ERB_IN_NODE_T));
 
   ast_node_init(&erb_in_node->base, AST_ERB_IN_NODE, start_position, end_position, errors);
@@ -415,6 +418,7 @@ AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content,
   erb_in_node->tag_opening = token_copy(tag_opening);
   erb_in_node->content = token_copy(content);
   erb_in_node->tag_closing = token_copy(tag_closing);
+  erb_in_node->then_keyword = then_keyword;
   erb_in_node->statements = statements;
 
   return erb_in_node;
@@ -726,6 +730,7 @@ static void ast_free_erb_if_node(AST_ERB_IF_NODE_T* erb_if_node) {
   if (erb_if_node->tag_opening != NULL) { token_free(erb_if_node->tag_opening); }
   if (erb_if_node->content != NULL) { token_free(erb_if_node->content); }
   if (erb_if_node->tag_closing != NULL) { token_free(erb_if_node->tag_closing); }
+  if (erb_if_node->then_keyword != NULL) { free(erb_if_node->then_keyword); }
   if (erb_if_node->statements != NULL) {
     for (size_t i = 0; i < hb_array_size(erb_if_node->statements); i++) {
       AST_NODE_T* child = hb_array_get(erb_if_node->statements, i);
@@ -761,6 +766,7 @@ static void ast_free_erb_when_node(AST_ERB_WHEN_NODE_T* erb_when_node) {
   if (erb_when_node->tag_opening != NULL) { token_free(erb_when_node->tag_opening); }
   if (erb_when_node->content != NULL) { token_free(erb_when_node->content); }
   if (erb_when_node->tag_closing != NULL) { token_free(erb_when_node->tag_closing); }
+  if (erb_when_node->then_keyword != NULL) { free(erb_when_node->then_keyword); }
   if (erb_when_node->statements != NULL) {
     for (size_t i = 0; i < hb_array_size(erb_when_node->statements); i++) {
       AST_NODE_T* child = hb_array_get(erb_when_node->statements, i);
@@ -933,6 +939,7 @@ static void ast_free_erb_unless_node(AST_ERB_UNLESS_NODE_T* erb_unless_node) {
   if (erb_unless_node->tag_opening != NULL) { token_free(erb_unless_node->tag_opening); }
   if (erb_unless_node->content != NULL) { token_free(erb_unless_node->content); }
   if (erb_unless_node->tag_closing != NULL) { token_free(erb_unless_node->tag_closing); }
+  if (erb_unless_node->then_keyword != NULL) { free(erb_unless_node->then_keyword); }
   if (erb_unless_node->statements != NULL) {
     for (size_t i = 0; i < hb_array_size(erb_unless_node->statements); i++) {
       AST_NODE_T* child = hb_array_get(erb_unless_node->statements, i);
@@ -959,6 +966,7 @@ static void ast_free_erb_in_node(AST_ERB_IN_NODE_T* erb_in_node) {
   if (erb_in_node->tag_opening != NULL) { token_free(erb_in_node->tag_opening); }
   if (erb_in_node->content != NULL) { token_free(erb_in_node->content); }
   if (erb_in_node->tag_closing != NULL) { token_free(erb_in_node->tag_closing); }
+  if (erb_in_node->then_keyword != NULL) { free(erb_in_node->then_keyword); }
   if (erb_in_node->statements != NULL) {
     for (size_t i = 0; i < hb_array_size(erb_in_node->statements); i++) {
       AST_NODE_T* child = hb_array_get(erb_in_node->statements, i);

data/src/ast_pretty_print.c

@@ -265,6 +265,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_if_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_if_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_if_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("then_keyword"), indent, relative_indent, false, buffer);
+      if (erb_if_node->then_keyword) {
+        char then_keyword_location_string[128];
+        sprintf(then_keyword_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          erb_if_node->then_keyword->start.line,
+          erb_if_node->then_keyword->start.column,
+          erb_if_node->then_keyword->end.line,
+          erb_if_node->then_keyword->end.column);
+        hb_buffer_append(buffer, then_keyword_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       pretty_print_array(hb_string("statements"), erb_if_node->statements, indent, relative_indent, false, buffer);
 
       pretty_print_label(hb_string("subsequent"), indent, relative_indent, false, buffer);
@@ -330,6 +343,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_when_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_when_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_when_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("then_keyword"), indent, relative_indent, false, buffer);
+      if (erb_when_node->then_keyword) {
+        char then_keyword_location_string[128];
+        sprintf(then_keyword_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          erb_when_node->then_keyword->start.line,
+          erb_when_node->then_keyword->start.column,
+          erb_when_node->then_keyword->end.line,
+          erb_when_node->then_keyword->end.column);
+        hb_buffer_append(buffer, then_keyword_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       pretty_print_array(hb_string("statements"), erb_when_node->statements, indent, relative_indent, true, buffer);
     } break;
 
@@ -602,6 +628,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_unless_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_unless_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_unless_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("then_keyword"), indent, relative_indent, false, buffer);
+      if (erb_unless_node->then_keyword) {
+        char then_keyword_location_string[128];
+        sprintf(then_keyword_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          erb_unless_node->then_keyword->start.line,
+          erb_unless_node->then_keyword->start.column,
+          erb_unless_node->then_keyword->end.line,
+          erb_unless_node->then_keyword->end.column);
+        hb_buffer_append(buffer, then_keyword_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       pretty_print_array(hb_string("statements"), erb_unless_node->statements, indent, relative_indent, false, buffer);
 
       pretty_print_label(hb_string("else_clause"), indent, relative_indent, false, buffer);
@@ -651,6 +690,19 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_in_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_in_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_in_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      pretty_print_label(hb_string("then_keyword"), indent, relative_indent, false, buffer);
+      if (erb_in_node->then_keyword) {
+        char then_keyword_location_string[128];
+        sprintf(then_keyword_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          erb_in_node->then_keyword->start.line,
+          erb_in_node->then_keyword->start.column,
+          erb_in_node->then_keyword->end.line,
+          erb_in_node->then_keyword->end.column);
+        hb_buffer_append(buffer, then_keyword_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       pretty_print_array(hb_string("statements"), erb_in_node->statements, indent, relative_indent, true, buffer);
     } break;
 

data/src/include/analyze_helpers.h

@@ -25,9 +25,15 @@ bool has_rescue_node(analyzed_ruby_T* analyzed);
 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_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
+bool is_do_block(pm_location_t opening_location);
+bool is_brace_block(pm_location_t opening_location);
+bool is_closing_brace(pm_location_t location);
+bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc);
+
 bool search_if_nodes(const pm_node_t* node, void* data);
 bool search_block_nodes(const pm_node_t* node, void* data);
 bool search_case_nodes(const pm_node_t* node, void* data);
@@ -46,6 +52,7 @@ bool search_in_nodes(analyzed_ruby_T* analyzed);
 bool search_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_ensure_nodes(analyzed_ruby_T* analyzed);
 bool search_yield_nodes(const pm_node_t* node, void* data);
+bool search_then_keywords(const pm_node_t* node, void* data);
 bool search_unclosed_control_flows(const pm_node_t* node, void* data);
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node);

data/src/include/analyzed_ruby.h

@@ -29,6 +29,7 @@ typedef struct ANALYZED_RUBY_STRUCT {
   int ensure_node_count;
   int unless_node_count;
   int yield_node_count;
+  int then_keyword_count;
   int unclosed_control_flow_count;
 } analyzed_ruby_T;