herb 0.1.1 → 0.2.0

data/sig/serialized_ast_nodes.rbs

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+# typed: true
+
+# NOTE: This file is generated by the templates/template.rb script and should not be
+# modified manually. See /Users/marcoroth/Development/herb-release/templates/sig/serialized_ast_nodes.rbs.erb
+
+module Herb
+  type serialized_document_node = serialized_node & {
+    children: Array[Herb::AST::Node],
+  }
+
+  type serialized_literal_node = serialized_node & {
+    content: String,
+  }
+
+  type serialized_html_open_tag_node = serialized_node & {
+    tag_opening: Herb::Token,
+    tag_name: Herb::Token,
+    tag_closing: Herb::Token,
+    children: Array[Herb::AST::Node],
+    is_void: bool,
+  }
+
+  type serialized_html_close_tag_node = serialized_node & {
+    tag_opening: Herb::Token,
+    tag_name: Herb::Token,
+    tag_closing: Herb::Token,
+  }
+
+  type serialized_html_self_close_tag_node = serialized_node & {
+    tag_opening: Herb::Token,
+    tag_name: Herb::Token,
+    attributes: Array[Herb::AST::HTMLAttributeNode],
+    tag_closing: Herb::Token,
+    is_void: bool,
+  }
+
+  type serialized_html_element_node = serialized_node & {
+    open_tag: Herb::AST::HTMLOpenTagNode,
+    tag_name: Herb::Token,
+    body: Array[Herb::AST::Node],
+    close_tag: Herb::AST::HTMLCloseTagNode,
+    is_void: bool,
+  }
+
+  type serialized_html_attribute_value_node = serialized_node & {
+    open_quote: Herb::Token,
+    children: Array[Herb::AST::Node],
+    close_quote: Herb::Token,
+    quoted: bool,
+  }
+
+  type serialized_html_attribute_name_node = serialized_node & {
+    name: Herb::Token,
+  }
+
+  type serialized_html_attribute_node = serialized_node & {
+    name: Herb::AST::HTMLAttributeNameNode,
+    equals: Herb::Token,
+    value: Herb::AST::HTMLAttributeValueNode,
+  }
+
+  type serialized_html_text_node = serialized_node & {
+    content: String,
+  }
+
+  type serialized_html_comment_node = serialized_node & {
+    comment_start: Herb::Token,
+    children: Array[Herb::AST::Node],
+    comment_end: Herb::Token,
+  }
+
+  type serialized_html_doctype_node = serialized_node & {
+    tag_opening: Herb::Token,
+    children: Array[Herb::AST::Node],
+    tag_closing: Herb::Token,
+  }
+
+  type serialized_whitespace_node = serialized_node & {
+    value: Herb::Token,
+  }
+
+  type serialized_erb_content_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    analyzed_ruby: nil,
+    parsed: bool,
+    valid: bool,
+  }
+
+  type serialized_erb_end_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+  }
+
+  type serialized_erb_else_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+  }
+
+  type serialized_erb_if_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+    subsequent: Herb::AST::Node,
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_block_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    body: Array[Herb::AST::Node],
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_when_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+  }
+
+  type serialized_erb_case_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    children: Array[Herb::AST::Node],
+    conditions: Array[Herb::AST::ERBWhenNode],
+    else_clause: Herb::AST::ERBElseNode,
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_case_match_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    children: Array[Herb::AST::Node],
+    conditions: Array[Herb::AST::ERBInNode],
+    else_clause: Herb::AST::ERBElseNode,
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_while_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_until_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_for_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_rescue_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+    subsequent: Herb::AST::ERBRescueNode,
+  }
+
+  type serialized_erb_ensure_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+  }
+
+  type serialized_erb_begin_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+    rescue_clause: Herb::AST::ERBRescueNode,
+    else_clause: Herb::AST::ERBElseNode,
+    ensure_clause: Herb::AST::ERBEnsureNode,
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_unless_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+    else_clause: Herb::AST::ERBElseNode,
+    end_node: Herb::AST::ERBEndNode,
+  }
+
+  type serialized_erb_yield_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+  }
+
+  type serialized_erb_in_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    statements: Array[Herb::AST::Node],
+  }
+
+end

data/src/analyze.c

@@ -25,6 +25,7 @@ static analyzed_ruby_T* herb_analyze_ruby(char* source) {
   pm_visit_node(analyzed->root, search_if_nodes, analyzed);
   pm_visit_node(analyzed->root, search_block_nodes, analyzed);
   pm_visit_node(analyzed->root, search_case_nodes, analyzed);
+  pm_visit_node(analyzed->root, search_case_match_nodes, analyzed);
   pm_visit_node(analyzed->root, search_while_nodes, analyzed);
   pm_visit_node(analyzed->root, search_for_nodes, analyzed);
   pm_visit_node(analyzed->root, search_until_nodes, analyzed);
@@ -35,8 +36,10 @@ static analyzed_ruby_T* herb_analyze_ruby(char* source) {
   search_else_nodes(analyzed);
   search_end_nodes(analyzed);
   search_when_nodes(analyzed);
+  search_in_nodes(analyzed);
   search_rescue_nodes(analyzed);
   search_ensure_nodes(analyzed);
+  search_yield_nodes(analyzed);
   search_block_closing_nodes(analyzed);
 
   return analyzed;
@@ -84,7 +87,9 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   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; }
@@ -93,6 +98,7 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (has_until_node(ruby)) { return CONTROL_TYPE_UNTIL; }
   if (has_for_node(ruby)) { return CONTROL_TYPE_FOR; }
   if (has_block_node(ruby)) { return CONTROL_TYPE_BLOCK; }
+  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
   if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
 
   return CONTROL_TYPE_UNKNOWN;
@@ -102,7 +108,8 @@ static bool is_subsequent_type(control_type_t parent_type, control_type_t child_
   switch (parent_type) {
     case CONTROL_TYPE_IF:
     case CONTROL_TYPE_ELSIF: return child_type == CONTROL_TYPE_ELSIF || child_type == CONTROL_TYPE_ELSE;
-    case CONTROL_TYPE_CASE: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
+    case CONTROL_TYPE_CASE:
+    case CONTROL_TYPE_CASE_MATCH: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
     case CONTROL_TYPE_BEGIN:
       return child_type == CONTROL_TYPE_RESCUE || child_type == CONTROL_TYPE_ELSE || child_type == CONTROL_TYPE_ENSURE;
     case CONTROL_TYPE_RESCUE: return child_type == CONTROL_TYPE_RESCUE;
@@ -117,6 +124,7 @@ static bool is_terminator_type(control_type_t parent_type, control_type_t child_
 
   switch (parent_type) {
     case CONTROL_TYPE_WHEN: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
+    case CONTROL_TYPE_IN: return child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE;
     case CONTROL_TYPE_BLOCK: return child_type == CONTROL_TYPE_BLOCK_CLOSE;
 
     default: return is_subsequent_type(parent_type, child_type);
@@ -163,27 +171,46 @@ static AST_NODE_T* create_control_node(
       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:
+    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* non_when_children = array_init(8);
+      array_T* in_conditions = array_init(8);
+      array_T* non_when_non_in_children = array_init(8);
 
       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);
+        } else if (child && child->type == AST_ERB_IN_NODE) {
+          array_append(in_conditions, child);
         } else {
-          array_append(non_when_children, child);
+          array_append(non_when_non_in_children, child);
         }
       }
 
+      if (array_size(in_conditions) > 0) {
+        return (AST_NODE_T*) ast_erb_case_match_node_init(
+          tag_opening,
+          content,
+          tag_closing,
+          non_when_non_in_children,
+          in_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_children,
+        non_when_non_in_children,
         when_conditions,
         else_node,
         end_node,
@@ -198,6 +225,11 @@ static AST_NODE_T* create_control_node(
         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);
+    }
+
     case CONTROL_TYPE_BEGIN: {
       AST_ERB_RESCUE_NODE_T* rescue_clause = NULL;
       AST_ERB_ELSE_NODE_T* else_clause = NULL;
@@ -320,6 +352,11 @@ 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);
+    }
+
     default: array_free(&errors); return NULL;
   }
 }
@@ -333,9 +370,10 @@ static size_t process_control_structure(
 
   index++;
 
-  if (initial_type == CONTROL_TYPE_CASE) {
+  if (initial_type == CONTROL_TYPE_CASE || initial_type == CONTROL_TYPE_CASE_MATCH) {
     array_T* when_conditions = array_init(8);
-    array_T* non_when_children = array_init(8);
+    array_T* in_conditions = array_init(8);
+    array_T* non_when_non_in_children = array_init(8);
 
     while (index < array_size(array)) {
       AST_NODE_T* next_node = array_get(array, index);
@@ -346,10 +384,10 @@ static size_t process_control_structure(
         AST_ERB_CONTENT_NODE_T* erb_content = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(erb_content);
 
-        if (next_type == CONTROL_TYPE_WHEN) { break; }
+        if (next_type == CONTROL_TYPE_WHEN || next_type == CONTROL_TYPE_IN) { break; }
       }
 
-      array_append(non_when_children, next_node);
+      array_append(non_when_non_in_children, next_node);
       index++;
     }
 
@@ -359,7 +397,7 @@ static size_t process_control_structure(
       if (!next_node) { break; }
 
       if (next_node->type != AST_ERB_CONTENT_NODE) {
-        array_append(non_when_children, next_node);
+        array_append(non_when_non_in_children, next_node);
         index++;
         continue;
       }
@@ -380,7 +418,8 @@ static size_t process_control_structure(
             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_WHEN || child_type == CONTROL_TYPE_ELSE || child_type == CONTROL_TYPE_END) {
+            if (child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE
+                || child_type == CONTROL_TYPE_END) {
               break;
             }
           }
@@ -401,11 +440,47 @@ static size_t process_control_structure(
 
         array_append(when_conditions, (AST_NODE_T*) when_node);
 
+        continue;
+      } else if (next_type == CONTROL_TYPE_IN) {
+        array_T* in_statements = 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_IN || child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE
+                || child_type == CONTROL_TYPE_END) {
+              break;
+            }
+          }
+
+          array_append(in_statements, child);
+          index++;
+        }
+
+        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)
+        );
+
+        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_children, next_node);
+        array_append(non_when_non_in_children, next_node);
         index++;
       }
     }
@@ -486,13 +561,34 @@ static size_t process_control_structure(
     } 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;
+    }
+
+    if (array_size(in_conditions) > 0) {
+      AST_ERB_CASE_MATCH_NODE_T* case_match_node = ast_erb_case_match_node_init(
+        erb_node->tag_opening,
+        erb_node->content,
+        erb_node->tag_closing,
+        non_when_non_in_children,
+        in_conditions,
+        else_clause,
+        end_node,
+        start_position,
+        end_position,
+        array_init(8)
+      );
+
+      array_append(output_array, (AST_NODE_T*) case_match_node);
+      return index;
     }
 
     AST_ERB_CASE_NODE_T* case_node = ast_erb_case_node_init(
       erb_node->tag_opening,
       erb_node->content,
       erb_node->tag_closing,
-      non_when_children,
+      non_when_non_in_children,
       when_conditions,
       else_clause,
       end_node,
@@ -845,36 +941,15 @@ static size_t process_block_children(
 
     if (is_terminator_type(parent_type, child_type)) { break; }
 
-    if (parent_type == CONTROL_TYPE_CASE && child_type == CONTROL_TYPE_WHEN) {
-      array_T* when_statements = array_init(8);
-
-      index++;
-
-      index = process_block_children(node, array, index, when_statements, context, CONTROL_TYPE_WHEN);
-
-      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)
-      );
-
-      array_append(children_array, (AST_NODE_T*) when_node);
-      continue;
-    }
-
-    if (child_type == CONTROL_TYPE_IF || child_type == CONTROL_TYPE_CASE || 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) {
+    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);
       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)); }
 
-      free(temp_array);
+      array_free(&temp_array);
 
       index = new_index;
       continue;
@@ -908,12 +983,14 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
     switch (type) {
       case CONTROL_TYPE_IF:
       case CONTROL_TYPE_CASE:
+      case CONTROL_TYPE_CASE_MATCH:
       case CONTROL_TYPE_BEGIN:
       case CONTROL_TYPE_UNLESS:
       case CONTROL_TYPE_WHILE:
       case CONTROL_TYPE_UNTIL:
       case CONTROL_TYPE_FOR:
       case CONTROL_TYPE_BLOCK:
+      case CONTROL_TYPE_YIELD:
         index = process_control_structure(node, array, index, new_array, context, type);
         continue;
 
@@ -933,22 +1010,30 @@ static bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
 
   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 (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_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_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);
   }
 
   herb_visit_child_nodes(node, transform_erb_nodes, data);
@@ -968,6 +1053,7 @@ void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source)
 
   herb_analyze_parse_errors(document, source);
 
+  array_free(&context->ruby_context_stack);
   free(context);
 }
 
@@ -977,13 +1063,22 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
   pm_parser_t parser;
   pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), NULL);
 
-  pm_parse(&parser);
+  pm_node_t* root = pm_parse(&parser);
 
   for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head; error != NULL;
        error = (const pm_diagnostic_t*) error->node.next) {
-    array_append(
-      document->base.errors,
-      ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser)
-    );
+
+    RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser);
+
+    // TODO: ideally this shouldn't be hard-coded
+    if (strcmp(parse_error->diagnostic_id, "invalid_yield") == 0) {
+      error_free((ERROR_T*) parse_error);
+    } else {
+      array_append(document->base.errors, parse_error);
+    }
   }
+
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+  free(extracted_ruby);
 }

data/src/analyze_helpers.c

@@ -32,10 +32,18 @@ bool has_case_node(analyzed_ruby_T* analyzed) {
   return analyzed->has_case_node;
 }
 
+bool has_case_match_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_case_match_node;
+}
+
 bool has_when_node(analyzed_ruby_T* analyzed) {
   return analyzed->has_when_node;
 }
 
+bool has_in_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_in_node;
+}
+
 bool has_for_node(analyzed_ruby_T* analyzed) {
   return analyzed->has_for_node;
 }
@@ -64,6 +72,10 @@ bool has_unless_node(analyzed_ruby_T* analyzed) {
   return analyzed->has_unless_node;
 }
 
+bool has_yield_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_yield_node;
+}
+
 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,7 +114,7 @@ bool search_block_nodes(const pm_node_t* node, void* data) {
 bool search_case_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_CASE_MATCH_NODE) {
+  if (node->type == PM_CASE_NODE) {
     analyzed->has_case_node = true;
     return true;
   } else {
@@ -112,6 +124,19 @@ bool search_case_nodes(const pm_node_t* node, void* data) {
   return false;
 }
 
+bool search_case_match_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_CASE_MATCH_NODE) {
+    analyzed->has_case_match_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_case_match_nodes, analyzed);
+  }
+
+  return false;
+}
+
 bool search_while_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
@@ -222,6 +247,15 @@ bool search_when_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
+bool search_in_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected 'in', ignoring it")) {
+    analyzed->has_in_node = true;
+    return true;
+  }
+
+  return false;
+}
+
 bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'rescue', ignoring it")) {
     analyzed->has_rescue_node = true;
@@ -239,3 +273,12 @@ bool search_ensure_nodes(analyzed_ruby_T* analyzed) {
 
   return false;
 }
+
+bool search_yield_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "Invalid yield")) {
+    analyzed->has_yield_node = true;
+    return true;
+  }
+
+  return false;
+}