herb 0.11.0-arm-linux-gnu → 0.11.1-arm-linux-gnu

data/src/analyze/analyze_helpers.c

@@ -226,23 +226,6 @@ bool has_error_message(analyzed_ruby_T* analyzed, const char* message) {
   return false;
 }
 
-bool search_if_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_IF_NODE) {
-    const pm_if_node_t* if_node = (const pm_if_node_t*) node;
-
-    bool has_if_keyword = if_node->if_keyword_loc.start != NULL && if_node->if_keyword_loc.end != NULL;
-    bool has_end_keyword = if_node->end_keyword_loc.start != NULL && if_node->end_keyword_loc.end != NULL;
-
-    if (has_if_keyword && has_end_keyword) { analyzed->if_node_count++; }
-  }
-
-  pm_visit_child_nodes(node, search_if_nodes, analyzed);
-
-  return false;
-}
-
 bool is_do_block(pm_location_t opening_location) {
   size_t length = opening_location.end - opening_location.start;
 
@@ -285,257 +268,136 @@ bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_lo
   return false;
 }
 
-bool search_block_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_BLOCK_NODE) {
-    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_valid_block_closing(block_node->opening_loc, block_node->closing_loc);
-
-    if (has_opening && is_unclosed) { analyzed->block_node_count++; }
-  }
-
-  if (node->type == PM_LAMBDA_NODE) {
-    pm_lambda_node_t* lambda_node = (pm_lambda_node_t*) node;
-
-    bool has_opening = is_do_block(lambda_node->opening_loc) || is_brace_block(lambda_node->opening_loc);
-    bool is_unclosed = !has_valid_block_closing(lambda_node->opening_loc, lambda_node->closing_loc);
-
-    if (has_opening && is_unclosed) { analyzed->block_node_count++; }
-  }
-
-  pm_visit_child_nodes(node, search_block_nodes, analyzed);
-
-  return false;
-}
-
-bool search_case_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_CASE_NODE) { analyzed->case_node_count++; }
-
-  pm_visit_child_nodes(node, search_case_nodes, analyzed);
-
-  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->case_match_node_count++; }
-
-  pm_visit_child_nodes(node, search_case_match_nodes, analyzed);
-
-  return false;
+static bool has_keyword_location(pm_location_t location) {
+  return location.start != NULL && location.end != NULL;
 }
 
-bool search_while_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_WHILE_NODE) { analyzed->while_node_count++; }
-
-  pm_visit_child_nodes(node, search_while_nodes, analyzed);
+static bool is_unclosed_block(pm_location_t opening_loc, pm_location_t closing_loc) {
+  bool has_opening = is_do_block(opening_loc) || is_brace_block(opening_loc);
 
-  return false;
+  return has_opening && !has_valid_block_closing(opening_loc, closing_loc);
 }
 
-bool search_for_nodes(const pm_node_t* node, void* data) {
+bool search_control_flow_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_FOR_NODE) { analyzed->for_node_count++; }
-
-  pm_visit_child_nodes(node, search_for_nodes, analyzed);
-
-  return false;
-}
-
-bool search_until_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_UNTIL_NODE) { analyzed->until_node_count++; }
-
-  pm_visit_child_nodes(node, search_until_nodes, analyzed);
-
-  return false;
-}
-
-bool search_begin_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_BEGIN_NODE) { analyzed->begin_node_count++; }
-
-  pm_visit_child_nodes(node, search_begin_nodes, analyzed);
-
-  return false;
-}
-
-bool search_unless_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_UNLESS_NODE) {
-    const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
-
-    bool has_if_keyword = unless_node->keyword_loc.start != NULL && unless_node->keyword_loc.end != NULL;
-    bool has_end_keyword = unless_node->end_keyword_loc.start != NULL && unless_node->end_keyword_loc.end != NULL;
-
-    if (has_if_keyword && has_end_keyword) { analyzed->unless_node_count++; }
-  }
-
-  pm_visit_child_nodes(node, search_unless_nodes, analyzed);
-
-  return false;
-}
-
-bool search_when_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_WHEN_NODE) { analyzed->when_node_count++; }
-
-  pm_visit_child_nodes(node, search_when_nodes, analyzed);
-
-  return false;
-}
-
-bool search_in_nodes(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 (node->type == PM_IN_NODE) { analyzed->in_node_count++; }
-  if (node->type == PM_CASE_MATCH_NODE) {
-    const pm_case_match_node_t* case_match_node = (const pm_case_match_node_t*) node;
+      if (has_keyword_location(if_node->if_keyword_loc) && has_keyword_location(if_node->end_keyword_loc)) {
+        analyzed->if_node_count++;
+      }
 
-    if (case_match_node->predicate != NULL && case_match_node->predicate->type == PM_MATCH_PREDICATE_NODE) {
-      analyzed->in_node_count++;
+      if (has_keyword_location(if_node->then_keyword_loc)) { analyzed->then_keyword_count++; }
+      break;
     }
-  }
-
-  pm_visit_child_nodes(node, search_in_nodes, analyzed);
 
-  return false;
-}
+    case PM_UNLESS_NODE: {
+      const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
 
-bool search_unexpected_elsif_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'elsif', ignoring it")) {
-    analyzed->elsif_node_count++;
-    return true;
-  }
+      if (has_keyword_location(unless_node->keyword_loc) && has_keyword_location(unless_node->end_keyword_loc)) {
+        analyzed->unless_node_count++;
+      }
 
-  return false;
-}
+      if (has_keyword_location(unless_node->then_keyword_loc)) { analyzed->then_keyword_count++; }
+      break;
+    }
 
-bool search_unexpected_else_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'else', ignoring it")) {
-    analyzed->else_node_count++;
-    return true;
-  }
+    case PM_WHEN_NODE: {
+      const pm_when_node_t* when_node = (const pm_when_node_t*) node;
 
-  return false;
-}
+      analyzed->when_node_count++;
 
-bool search_unexpected_end_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'end', ignoring it")) {
-    if (has_error_message(analyzed, "unexpected '=', ignoring it")) {
-      // `=end`
-      return false;
+      if (has_keyword_location(when_node->then_keyword_loc)) { analyzed->then_keyword_count++; }
+      break;
     }
 
-    analyzed->end_count++;
-    return true;
-  }
-
-  return false;
-}
-
-bool search_unexpected_block_closing_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected '}', ignoring it")) {
-    analyzed->block_closing_count++;
-    return true;
-  }
+    case PM_BLOCK_NODE: {
+      const pm_block_node_t* block_node = (const pm_block_node_t*) node;
 
-  return false;
-}
+      if (is_unclosed_block(block_node->opening_loc, block_node->closing_loc)) { analyzed->block_node_count++; }
+      break;
+    }
 
-bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'when', ignoring it")) {
-    analyzed->when_node_count++;
-    return true;
-  }
+    case PM_LAMBDA_NODE: {
+      const pm_lambda_node_t* lambda_node = (const pm_lambda_node_t*) node;
 
-  return false;
-}
+      if (is_unclosed_block(lambda_node->opening_loc, lambda_node->closing_loc)) { analyzed->block_node_count++; }
+      break;
+    }
 
-bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'in', ignoring it")) {
-    analyzed->in_node_count++;
-    return true;
-  }
+    case PM_CASE_MATCH_NODE: {
+      const pm_case_match_node_t* case_match_node = (const pm_case_match_node_t*) node;
 
-  return false;
-}
+      analyzed->case_match_node_count++;
 
-bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'rescue', ignoring it")) {
-    analyzed->rescue_node_count++;
-    return true;
-  }
+      if (case_match_node->predicate != NULL && case_match_node->predicate->type == PM_MATCH_PREDICATE_NODE) {
+        analyzed->in_node_count++;
+      }
+      break;
+    }
 
-  return false;
-}
+    case PM_CASE_NODE: analyzed->case_node_count++; break;
+    case PM_IN_NODE: analyzed->in_node_count++; break;
+    case PM_WHILE_NODE: analyzed->while_node_count++; break;
+    case PM_FOR_NODE: analyzed->for_node_count++; break;
+    case PM_UNTIL_NODE: analyzed->until_node_count++; break;
+    case PM_BEGIN_NODE: analyzed->begin_node_count++; break;
+    case PM_YIELD_NODE: analyzed->yield_node_count++; break;
 
-bool search_unexpected_ensure_nodes(analyzed_ruby_T* analyzed) {
-  if (has_error_message(analyzed, "unexpected 'ensure', ignoring it")) {
-    analyzed->ensure_node_count++;
-    return true;
+    default: break;
   }
 
-  return false;
-}
-
-bool search_yield_nodes(const pm_node_t* node, void* data) {
-  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
-
-  if (node->type == PM_YIELD_NODE) { analyzed->yield_node_count++; }
-
-  pm_visit_child_nodes(node, search_yield_nodes, analyzed);
+  pm_visit_child_nodes(node, search_control_flow_nodes, analyzed);
 
   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;
-    }
+void search_unexpected_keyword_errors(analyzed_ruby_T* analyzed) {
+  bool unexpected_elsif = false;
+  bool unexpected_else = false;
+  bool unexpected_end = false;
+  bool unexpected_equals = false;
+  bool unexpected_closing_brace = false;
+  bool unexpected_when = false;
+  bool unexpected_in = false;
+  bool unexpected_rescue = false;
+  bool unexpected_ensure = false;
 
-    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;
+  for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) analyzed->parser.error_list.head; error != NULL;
+       error = (const pm_diagnostic_t*) error->node.next) {
+    const char* message = error->message;
+
+    if (string_equals(message, "unexpected 'elsif', ignoring it")) {
+      unexpected_elsif = true;
+    } else if (string_equals(message, "unexpected 'else', ignoring it")) {
+      unexpected_else = true;
+    } else if (string_equals(message, "unexpected 'end', ignoring it")) {
+      unexpected_end = true;
+    } else if (string_equals(message, "unexpected '=', ignoring it")) {
+      unexpected_equals = true;
+    } else if (string_equals(message, "unexpected '}', ignoring it")) {
+      unexpected_closing_brace = true;
+    } else if (string_equals(message, "unexpected 'when', ignoring it")) {
+      unexpected_when = true;
+    } else if (string_equals(message, "unexpected 'in', ignoring it")) {
+      unexpected_in = true;
+    } else if (string_equals(message, "unexpected 'rescue', ignoring it")) {
+      unexpected_rescue = true;
+    } else if (string_equals(message, "unexpected 'ensure', ignoring it")) {
+      unexpected_ensure = true;
     }
-
-    default: break;
   }
 
-  pm_visit_child_nodes(node, search_then_keywords, analyzed);
-
-  return false;
+  if (unexpected_elsif) { analyzed->elsif_node_count++; }
+  if (unexpected_else) { analyzed->else_node_count++; }
+  if (unexpected_end && !unexpected_equals) { analyzed->end_count++; }
+  if (unexpected_when) { analyzed->when_node_count++; }
+  if (unexpected_in) { analyzed->in_node_count++; }
+  if (unexpected_rescue) { analyzed->rescue_node_count++; }
+  if (unexpected_ensure) { analyzed->ensure_node_count++; }
+  if (unexpected_closing_brace) { analyzed->block_closing_count++; }
 }
 
 static bool is_postfix_conditional(const pm_statements_node_t* statements, pm_location_t keyword_location) {

data/src/analyze/analyzed_ruby.c

@@ -34,6 +34,8 @@ analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
   analyzed->yield_node_count = 0;
   analyzed->then_keyword_count = 0;
   analyzed->unclosed_control_flow_count = 0;
+  analyzed->control_type = CONTROL_TYPE_UNKNOWN;
+  analyzed->control_type_detected = false;
 
   return analyzed;
 }

data/src/analyze/builders.c

@@ -367,6 +367,7 @@ static AST_NODE_T* build_yield_node(control_builder_context_T* context) {
     token_copy(context->tag_opening, context->allocator),
     token_copy(context->content, context->allocator),
     token_copy(context->tag_closing, context->allocator),
+    HERB_PRISM_NODE_EMPTY,
     context->start_position,
     context->end_position,
     context->errors,

data/src/analyze/control_type.c

@@ -194,13 +194,7 @@ static bool erb_content_is_unterminated(const AST_ERB_CONTENT_NODE_T* erb_node)
   return false;
 }
 
-control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
-  if (!erb_node || erb_node->base.type != AST_ERB_CONTENT_NODE) { return CONTROL_TYPE_UNKNOWN; }
-  if (erb_content_is_unterminated(erb_node)) { return CONTROL_TYPE_UNKNOWN; }
-
-  analyzed_ruby_T* ruby = erb_node->analyzed_ruby;
-
-  if (!ruby) { return CONTROL_TYPE_UNKNOWN; }
+static control_type_t detect_analyzed_control_type(analyzed_ruby_T* ruby) {
   if (ruby->valid) { return CONTROL_TYPE_UNKNOWN; }
 
   pm_node_t* root = ruby->root;
@@ -219,6 +213,22 @@ control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   return find_earliest_control_keyword(root, ruby->parser.start);
 }
 
+control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
+  if (!erb_node || erb_node->base.type != AST_ERB_CONTENT_NODE) { return CONTROL_TYPE_UNKNOWN; }
+  if (erb_content_is_unterminated(erb_node)) { return CONTROL_TYPE_UNKNOWN; }
+
+  analyzed_ruby_T* ruby = erb_node->analyzed_ruby;
+
+  if (!ruby) { return CONTROL_TYPE_UNKNOWN; }
+
+  if (!ruby->control_type_detected) {
+    ruby->control_type = detect_analyzed_control_type(ruby);
+    ruby->control_type_detected = true;
+  }
+
+  return ruby->control_type;
+}
+
 bool is_subsequent_type(control_type_t parent_type, control_type_t child_type) {
   switch (parent_type) {
     case CONTROL_TYPE_IF:

data/src/analyze/prism_annotate.c

@@ -170,6 +170,7 @@ static token_T* get_content_token(const AST_NODE_T* node) {
   switch (node->type) {
     case AST_ERB_CONTENT_NODE: return ((AST_ERB_CONTENT_NODE_T*) node)->content;
     case AST_ERB_RENDER_NODE: return ((AST_ERB_RENDER_NODE_T*) node)->content;
+    case AST_ERB_YIELD_NODE: return ((AST_ERB_YIELD_NODE_T*) node)->content;
     case AST_ERB_IF_NODE: return ((AST_ERB_IF_NODE_T*) node)->content;
     case AST_ERB_BLOCK_NODE: return ((AST_ERB_BLOCK_NODE_T*) node)->content;
     case AST_ERB_ITERATION_BLOCK_NODE: return ((AST_ERB_ITERATION_BLOCK_NODE_T*) node)->content;
@@ -188,6 +189,7 @@ static void set_prism_node(AST_NODE_T* node, herb_prism_node_T prism_ref) {
   switch (node->type) {
     case AST_ERB_CONTENT_NODE: ((AST_ERB_CONTENT_NODE_T*) node)->prism_node = prism_ref; break;
     case AST_ERB_RENDER_NODE: ((AST_ERB_RENDER_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_YIELD_NODE: ((AST_ERB_YIELD_NODE_T*) node)->prism_node = prism_ref; break;
     case AST_ERB_IF_NODE: ((AST_ERB_IF_NODE_T*) node)->prism_node = prism_ref; break;
     case AST_ERB_BLOCK_NODE: ((AST_ERB_BLOCK_NODE_T*) node)->prism_node = prism_ref; break;
     case AST_ERB_ITERATION_BLOCK_NODE: ((AST_ERB_ITERATION_BLOCK_NODE_T*) node)->prism_node = prism_ref; break;
@@ -202,6 +204,12 @@ static void set_prism_node(AST_NODE_T* node, herb_prism_node_T prism_ref) {
   }
 }
 
+static size_t prism_node_start(pm_parser_t* parser, hb_narray_T* node_list, size_t index) {
+  pm_node_t* prism_node = *(pm_node_t**) hb_narray_get(node_list, index);
+
+  return (size_t) (prism_node->location.start - parser->start);
+}
+
 static herb_prism_node_T find_prism_node_for_herb_node(
   pm_parser_t* parser,
   hb_narray_T* node_list,
@@ -215,17 +223,29 @@ static herb_prism_node_T find_prism_node_for_herb_node(
   uint32_t content_from = content->range.from;
   uint32_t content_to = content->range.to;
 
-  for (size_t i = 0; i < hb_narray_size(node_list); i++) {
-    pm_node_t* prism_node = *(pm_node_t**) hb_narray_get(node_list, i);
-    size_t prism_start = (size_t) (prism_node->location.start - parser->start);
+  size_t low = 0;
+  size_t high = hb_narray_size(node_list);
 
-    if (prism_start >= content_from && prism_start < content_to) {
-      result.node = prism_node;
-      result.parser = parser;
-      break;
+  while (low < high) {
+    size_t middle = low + (high - low) / 2;
+
+    if (prism_node_start(parser, node_list, middle) < content_from) {
+      low = middle + 1;
+    } else {
+      high = middle;
     }
   }
 
+  if (low >= hb_narray_size(node_list) || prism_node_start(parser, node_list, low) >= content_to) { return result; }
+
+  pm_node_t* prism_node = *(pm_node_t**) hb_narray_get(node_list, low);
+  size_t prism_end = (size_t) (prism_node->location.end - parser->start);
+
+  result.node = prism_node;
+  result.parser = parser;
+  result.source_start = content_from;
+  result.source_end = prism_end > content_to ? (uint32_t) prism_end : content_to;
+
   return result;
 }
 
@@ -237,7 +257,8 @@ static bool annotate_visitor(const AST_NODE_T* node, void* data) {
   pm_parser_t* parser;
   hb_narray_T* node_list;
 
-  if (node->type == AST_ERB_CONTENT_NODE || node->type == AST_ERB_RENDER_NODE || context->prism_nodes_deep) {
+  if (node->type == AST_ERB_CONTENT_NODE || node->type == AST_ERB_RENDER_NODE || node->type == AST_ERB_YIELD_NODE
+      || context->prism_nodes_deep) {
     parser = context->parser;
     node_list = context->node_list;
   } else {
@@ -253,7 +274,9 @@ static bool annotate_visitor(const AST_NODE_T* node, void* data) {
 }
 
 static bool collect_content_ranges_visitor(const AST_NODE_T* node, void* data) {
-  if (node->type != AST_ERB_CONTENT_NODE && node->type != AST_ERB_RENDER_NODE) { return true; }
+  if (node->type != AST_ERB_CONTENT_NODE && node->type != AST_ERB_RENDER_NODE && node->type != AST_ERB_YIELD_NODE) {
+    return true;
+  }
 
   hb_narray_T* ranges = (hb_narray_T*) data;
   token_T* content = get_content_token(node);

data/src/ast/ast_nodes.c

@@ -712,7 +712,7 @@ AST_ERB_STRICT_LOCALS_NODE_T* ast_erb_strict_locals_node_init(token_T* tag_openi
   return erb_strict_locals_node;
 }
 
-AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
+AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, herb_prism_node_T prism_node, position_T start_position, position_T end_position, hb_array_T* errors, hb_allocator_T* allocator) {
   AST_ERB_YIELD_NODE_T* erb_yield_node = hb_allocator_alloc(allocator, sizeof(AST_ERB_YIELD_NODE_T));
 
   if (!erb_yield_node) { return NULL; }
@@ -722,6 +722,7 @@ AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* con
   erb_yield_node->tag_opening = tag_opening;
   erb_yield_node->content = content;
   erb_yield_node->tag_closing = tag_closing;
+  erb_yield_node->prism_node = prism_node;
 
   return erb_yield_node;
 }
@@ -1628,6 +1629,7 @@ static void ast_free_erb_yield_node(AST_ERB_YIELD_NODE_T* erb_yield_node, hb_all
   if (erb_yield_node->tag_opening != NULL) { token_free(erb_yield_node->tag_opening, allocator); }
   if (erb_yield_node->content != NULL) { token_free(erb_yield_node->content, allocator); }
   if (erb_yield_node->tag_closing != NULL) { token_free(erb_yield_node->tag_closing, allocator); }
+  /* prism_node is a borrowed reference into the prism context, not freed here */
 
   ast_free_base_node(&erb_yield_node->base, allocator);
 }

data/src/ast/ast_pretty_print.c

@@ -1228,7 +1228,11 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_errors(node, indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_yield_node->tag_opening, hb_string("tag_opening"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_yield_node->content, hb_string("content"), indent, relative_indent, false, buffer);
-      pretty_print_token_property(erb_yield_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, true, buffer);
+      pretty_print_token_property(erb_yield_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
+      if (erb_yield_node->prism_node.node != NULL) {
+        pretty_print_label(hb_string("prism_node"), indent, relative_indent, true, buffer);
+        hb_buffer_append(buffer, " (pm_node_t*)\n");
+      }
     } break;
 
     case AST_ERB_IN_NODE: {