herb 0.8.6 → 0.8.8

data/templates/rust/src/ast/nodes.rs.erb

@@ -51,7 +51,7 @@ unsafe fn convert_errors(errors_array: *mut hb_array_T) -> Vec<AnyError> {
     return Vec::new();
   }
 
-  let count = (*errors_array).size;
+  let count = hb_array_size(errors_array);
   let mut errors = Vec::with_capacity(count);
 
   for index in 0..count {
@@ -105,12 +105,20 @@ unsafe fn convert_token_field(token_ptr: *mut token_T) -> Option<crate::Token> {
   }
 }
 
+unsafe fn convert_location_field(location_ptr: *const location_T) -> Option<Location> {
+  if location_ptr.is_null() {
+    None
+  } else {
+    Some(convert_location(*location_ptr))
+  }
+}
+
 unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec<AnyNode> {
   if children_array.is_null() {
     return Vec::new();
   }
 
-  let count = (*children_array).size;
+  let count = hb_array_size(children_array);
   let mut children = Vec::with_capacity(count);
 
   for index in 0..count {
@@ -212,6 +220,8 @@ unsafe fn convert_node(node_ptr: *const c_void) -> Option<AnyNode> {
       <%- else -%>
       <%= field.name %>: convert_node_field((*c_node_ptr).<%= field.name %> as *mut c_void),
       <%- end -%>
+      <%- when Herb::Template::LocationField -%>
+      <%= field.name %>: convert_location_field((*c_node_ptr).<%= field.name %>),
       <%- end -%>
       <%- end -%>
     })

data/templates/rust/src/nodes.rs.erb

@@ -253,6 +253,8 @@ pub struct <%= node.name %> {
   <%- end -%>
   <%- when Herb::Template::ElementSourceField -%>
   pub <%= field.name %>: String,
+  <%- when Herb::Template::LocationField -%>
+  pub <%= field.name %>: Option<Location>,
   <%- end -%>
   <%- end -%>
 }
@@ -361,6 +363,8 @@ impl Node for <%= node.name %> {
     output.push_str(&format!("{}{}: {}", "<%= symbol %>".white(), "<%= field.name %>".white(), format_array_value(&self.<%= field.name %>, &"<%= is_last ? "    " : "│   " %>".white().to_string())));
     <%- when Herb::Template::NodeField -%>
     output.push_str(&format!("{}{}: {}", "<%= symbol %>".white(), "<%= field.name %>".white(), format_node_value(&self.<%= field.name %>, &"<%= is_last ? "    " : "│   " %>".white().to_string(), <%= !is_last %>)));
+    <%- when Herb::Template::LocationField -%>
+    output.push_str(&format!("{}{}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), self.<%= field.name %>.as_ref().map(|l| format!("(location: {})", l).dimmed().to_string()).unwrap_or_else(|| "∅".magenta().to_string())));
     <%- end -%>
     <%- end -%>
     <%- else -%>

data/templates/src/ast_nodes.c.erb

@@ -27,11 +27,7 @@
   <%- when Herb::Template::NodeField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::ArrayField -%>
-  if (<%= field.name %> == NULL) {
-    <%= node.human %>-><%= field.name %> = hb_array_init(8);
-  } else {
-    <%= node.human %>-><%= field.name %> = <%= field.name %>;
-  }
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::BooleanField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::ElementSourceField -%>
@@ -44,6 +40,8 @@
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::VoidPointerField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::LocationField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>
@@ -77,7 +75,7 @@ void ast_free_base_node(AST_NODE_T* node) {
   if (node == NULL) { return; }
 
   if (node->errors) {
-    for (size_t i = 0; i < node->errors->size; i++) {
+    for (size_t i = 0; i < hb_array_size(node->errors); i++) {
       ERROR_T* child = hb_array_get(node->errors, i);
       if (child != NULL) { error_free(child); }
     }
@@ -103,7 +101,7 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
   ast_node_free((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::ArrayField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) {
-    for (size_t i = 0; i < <%= node.human %>-><%= field.name %>->size; i++) {
+    for (size_t i = 0; i < hb_array_size(<%= node.human %>-><%= field.name %>); i++) {
       AST_NODE_T* child = hb_array_get(<%= node.human %>-><%= field.name %>, i);
       if (child) { ast_node_free(child); }
     }
@@ -127,6 +125,8 @@ static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %
   free(<%= node.human %>-><%= field.name %>);
   <%- when Herb::Template::BooleanField -%>
   <%- when Herb::Template::ElementSourceField -%>
+  <%- when Herb::Template::LocationField -%>
+  if (<%= node.human %>-><%= field.name %> != NULL) { free(<%= node.human %>-><%= field.name %>); }
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>

data/templates/src/ast_pretty_print.c.erb

@@ -87,6 +87,20 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
       hb_buffer_append(buffer, " ?\n");
 
+      <%- when Herb::Template::LocationField -%>
+      pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
+      if (<%= node.human %>-><%= field.name %>) {
+        char <%= field.name %>_location_string[128];
+        sprintf(<%= field.name %>_location_string, " (location: (%u:%u)-(%u:%u))\n",
+          <%= node.human %>-><%= field.name %>->start.line,
+          <%= node.human %>-><%= field.name %>->start.column,
+          <%= node.human %>-><%= field.name %>->end.line,
+          <%= node.human %>-><%= field.name %>->end.column);
+        hb_buffer_append(buffer, <%= field.name %>_location_string);
+      } else {
+        hb_buffer_append(buffer, " ∅\n");
+      }
+
       <%- else -%>
       <%= field.inspect %>
       <%- end -%>

data/templates/src/errors.c.erb

@@ -167,7 +167,7 @@ void error_pretty_print_array(
     return;
   }
 
-  if (array->size == 0) {
+  if (hb_array_size(array) == 0) {
     pretty_print_property(hb_string(name), hb_string("[]"), indent, relative_indent, last_property, buffer);
 
     return;
@@ -178,17 +178,17 @@ void error_pretty_print_array(
   hb_buffer_append(buffer, "(");
 
   char count[16];
-  sprintf(count, "%zu", array->size);
+  sprintf(count, "%zu", hb_array_size(array));
   hb_buffer_append(buffer, count);
   hb_buffer_append(buffer, ")\n");
 
   if (indent < 20) {
-    for (size_t i = 0; i < array->size; i++) {
+    for (size_t i = 0; i < hb_array_size(array); i++) {
       ERROR_T* child = hb_array_get(array, i);
       pretty_print_indent(buffer, indent);
       pretty_print_indent(buffer, relative_indent + 1);
 
-      if (i == array->size - 1) {
+      if (i == hb_array_size(array) - 1) {
         hb_buffer_append(buffer, "└── ");
       } else {
         hb_buffer_append(buffer, "├── ");
@@ -196,7 +196,7 @@ void error_pretty_print_array(
 
       error_pretty_print(child, indent + 1, relative_indent + 1, buffer);
 
-      if (i != array->size - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
+      if (i != hb_array_size(array) - 1) { pretty_print_newline(indent + 1, relative_indent, buffer); }
     }
   }
 }

data/templates/src/visitor.c.erb

@@ -31,7 +31,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
       <%- when Herb::Template::ArrayField -%>
       if (<%= node.human %>-><%= field.name %> != NULL) {
-        for (size_t index = 0; index < <%= node.human %>-><%= field.name %>->size; index++) {
+        for (size_t index = 0; index < hb_array_size(<%= node.human %>-><%= field.name %>); index++) {
           herb_visit_node(hb_array_get(<%= node.human %>-><%= field.name %>, index), visitor, data);
         }
       }

data/templates/template.rb

@@ -117,6 +117,16 @@ module Herb
       end
     end
 
+    class LocationField < Field
+      def ruby_type
+        "Herb::Location"
+      end
+
+      def c_type
+        "location_T*"
+      end
+    end
+
     class IntegerField < Field
       def ruby_type
         "Integer"
@@ -210,6 +220,7 @@ module Herb
         when "token_type" then TokenTypeField
         when "string"     then StringField
         when "position"   then PositionField
+        when "location"   then LocationField
         when "size_t"     then SizeTField
         when "boolean"    then BooleanField
         when "prism_node" then PrismNodeField

data/templates/wasm/error_helpers.cpp.erb

@@ -66,7 +66,7 @@ val ErrorsArrayFromCArray(hb_array_T* array) {
   val result = Array.new_();
 
   if (array) {
-    for (size_t i = 0; i < array->size; i++) {
+    for (size_t i = 0; i < hb_array_size(array); i++) {
       ERROR_T* error = (ERROR_T*)hb_array_get(array, i);
       if (error) {
         result.call<void>("push", ErrorFromCStruct(error));

data/templates/wasm/nodes.cpp.erb

@@ -39,6 +39,12 @@ val <%= node.name %>FromCStruct(<%= node.struct_type %>* <%= node.human %>) {
   result.set("<%= field.name %>", NodesArrayFromCArray(<%= node.human %>-><%= field.name %>));
   <%- when Herb::Template::ElementSourceField -%>
   result.set("<%= field.name %>", CreateStringFromHbString(element_source_to_string(<%= node.human %>-><%= field.name %>)));
+  <%- when Herb::Template::LocationField -%>
+  if (<%= node.human %>-><%= field.name %>) {
+    result.set("<%= field.name %>", CreateLocation(*<%= node.human %>-><%= field.name %>));
+  } else {
+    result.set("<%= field.name %>", val::null());
+  }
   <%- else -%>
   result.set("<%= field.name %>", val::null());
   <%- end -%>
@@ -67,7 +73,7 @@ val NodesArrayFromCArray(hb_array_T* array) {
 
   val jsArray = val::array();
 
-  for (size_t i = 0; i < array->size; i++) {
+  for (size_t i = 0; i < hb_array_size(array); i++) {
     AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
     if (child_node) {

data/vendor/prism/include/prism/version.h

@@ -14,7 +14,7 @@
 /**
  * The minor version of the Prism library as an int.
  */
-#define PRISM_VERSION_MINOR 7
+#define PRISM_VERSION_MINOR 8
 
 /**
  * The patch version of the Prism library as an int.
@@ -24,6 +24,6 @@
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "1.7.0"
+#define PRISM_VERSION "1.8.0"
 
 #endif

data/vendor/prism/src/prism.c

@@ -3962,9 +3962,13 @@ pm_float_node_rational_create(pm_parser_t *parser, const pm_token_t *token) {
     memcpy(digits + (point - start), point + 1, (unsigned long) (end - point - 1));
     pm_integer_parse(&node->numerator, PM_INTEGER_BASE_DEFAULT, digits, digits + length - 1);
 
+    size_t fract_length = 0;
+    for (const uint8_t *fract = point; fract < end; ++fract) {
+        if (*fract != '_') ++fract_length;
+    }
     digits[0] = '1';
-    if (end - point > 1) memset(digits + 1, '0', (size_t) (end - point - 1));
-    pm_integer_parse(&node->denominator, PM_INTEGER_BASE_DEFAULT, digits, digits + (end - point));
+    if (fract_length > 1) memset(digits + 1, '0', fract_length - 1);
+    pm_integer_parse(&node->denominator, PM_INTEGER_BASE_DEFAULT, digits, digits + fract_length);
     xfree(digits);
 
     pm_integers_reduce(&node->numerator, &node->denominator);
@@ -12422,6 +12426,22 @@ expect1_heredoc_term(pm_parser_t *parser, const uint8_t *ident_start, size_t ide
     }
 }
 
+/**
+ * A special expect1 that attaches the error to the opening token location
+ * rather than the current position. This is useful for errors about missing
+ * closing tokens, where we want to point to the line with the opening token
+ * (e.g., `def`, `class`, `if`, `{`) rather than the end of the file.
+ */
+static void
+expect1_opening(pm_parser_t *parser, pm_token_type_t type, pm_diagnostic_id_t diag_id, const pm_token_t *opening) {
+    if (accept1(parser, type)) return;
+
+    pm_parser_err(parser, opening->start, opening->end, diag_id);
+
+    parser->previous.start = opening->end;
+    parser->previous.type = PM_TOKEN_MISSING;
+}
+
 static pm_node_t *
 parse_expression(pm_parser_t *parser, pm_binding_power_t binding_power, bool accepts_command_call, bool accepts_label, pm_diagnostic_id_t diag_id, uint16_t depth);
 
@@ -14764,7 +14784,7 @@ parse_block(pm_parser_t *parser, uint16_t depth) {
             statements = UP(parse_statements(parser, PM_CONTEXT_BLOCK_BRACES, (uint16_t) (depth + 1)));
         }
 
-        expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_BLOCK_TERM_BRACE);
+        expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_BLOCK_TERM_BRACE, &opening);
     } else {
         if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
             if (!match3(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_ENSURE)) {
@@ -14779,7 +14799,7 @@ parse_block(pm_parser_t *parser, uint16_t depth) {
             }
         }
 
-        expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_BLOCK_TERM_END);
+        expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_BLOCK_TERM_END, &opening);
     }
 
     pm_constant_id_list_t locals;
@@ -15204,7 +15224,7 @@ parse_conditional(pm_parser_t *parser, pm_context_t context, size_t opening_newl
 
         accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
         parser_warn_indentation_mismatch(parser, opening_newline_index, &else_keyword, false, false);
-        expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CONDITIONAL_TERM_ELSE);
+        expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CONDITIONAL_TERM_ELSE, &keyword);
 
         pm_else_node_t *else_node = pm_else_node_create(parser, &else_keyword, else_statements, &parser->previous);
 
@@ -15221,7 +15241,7 @@ parse_conditional(pm_parser_t *parser, pm_context_t context, size_t opening_newl
         }
     } else {
         parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, if_after_else, false);
-        expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CONDITIONAL_TERM);
+        expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CONDITIONAL_TERM, &keyword);
     }
 
     // Set the appropriate end location for all of the nodes in the subtree.
@@ -16202,7 +16222,7 @@ parse_pattern_constant_path(pm_parser_t *parser, pm_constant_id_list_t *captures
         if (!accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
             inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET, (uint16_t) (depth + 1));
             accept1(parser, PM_TOKEN_NEWLINE);
-            expect1(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_PATTERN_TERM_BRACKET);
+            expect1_opening(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_PATTERN_TERM_BRACKET, &opening);
         }
 
         closing = parser->previous;
@@ -16214,7 +16234,7 @@ parse_pattern_constant_path(pm_parser_t *parser, pm_constant_id_list_t *captures
         if (!accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
             inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN, (uint16_t) (depth + 1));
             accept1(parser, PM_TOKEN_NEWLINE);
-            expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN);
+            expect1_opening(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN, &opening);
         }
 
         closing = parser->previous;
@@ -16594,7 +16614,7 @@ parse_pattern_primitive(pm_parser_t *parser, pm_constant_id_list_t *captures, pm
             pm_node_t *inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET, (uint16_t) (depth + 1));
 
             accept1(parser, PM_TOKEN_NEWLINE);
-            expect1(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_PATTERN_TERM_BRACKET);
+            expect1_opening(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_PATTERN_TERM_BRACKET, &opening);
             pm_token_t closing = parser->previous;
 
             switch (PM_NODE_TYPE(inner)) {
@@ -16672,7 +16692,7 @@ parse_pattern_primitive(pm_parser_t *parser, pm_constant_id_list_t *captures, pm
                 node = parse_pattern_hash(parser, captures, first_node, (uint16_t) (depth + 1));
 
                 accept1(parser, PM_TOKEN_NEWLINE);
-                expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_PATTERN_TERM_BRACE);
+                expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_PATTERN_TERM_BRACE, &opening);
                 pm_token_t closing = parser->previous;
 
                 node->base.location.start = opening.start;
@@ -16798,7 +16818,7 @@ parse_pattern_primitive(pm_parser_t *parser, pm_constant_id_list_t *captures, pm
                     parser->pattern_matching_newlines = previous_pattern_matching_newlines;
 
                     accept1(parser, PM_TOKEN_NEWLINE);
-                    expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN);
+                    expect1_opening(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN, &lparen);
                     return UP(pm_pinned_expression_node_create(parser, expression, &operator, &lparen, &parser->previous));
                 }
                 default: {
@@ -16896,7 +16916,7 @@ parse_pattern_primitives(pm_parser_t *parser, pm_constant_id_list_t *captures, p
 
                 pm_node_t *body = parse_pattern(parser, captures, PM_PARSE_PATTERN_SINGLE, PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN, (uint16_t) (depth + 1));
                 accept1(parser, PM_TOKEN_NEWLINE);
-                expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN);
+                expect1_opening(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN, &opening);
                 pm_node_t *right = UP(pm_parentheses_node_create(parser, &opening, body, &parser->previous, 0));
 
                 if (!alternation) {
@@ -17748,7 +17768,8 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             pm_accepts_block_stack_push(parser, true);
             parser_lex(parser);
 
-            pm_hash_node_t *node = pm_hash_node_create(parser, &parser->previous);
+            pm_token_t opening = parser->previous;
+            pm_hash_node_t *node = pm_hash_node_create(parser, &opening);
 
             if (!match2(parser, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_EOF)) {
                 if (current_hash_keys != NULL) {
@@ -17763,7 +17784,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             }
 
             pm_accepts_block_stack_pop(parser);
-            expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_HASH_TERM);
+            expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_HASH_TERM, &opening);
             pm_hash_node_closing_loc_set(node, &parser->previous);
 
             return UP(node);
@@ -18380,7 +18401,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             }
 
             parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword, false, false);
-            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CASE_TERM);
+            expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CASE_TERM, &case_keyword);
 
             if (PM_NODE_TYPE_P(node, PM_CASE_NODE)) {
                 pm_case_node_end_keyword_loc_set((pm_case_node_t *) node, &parser->previous);
@@ -18413,7 +18434,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
 
             pm_begin_node_t *begin_node = pm_begin_node_create(parser, &begin_keyword, begin_statements);
             parse_rescues(parser, opening_newline_index, &begin_keyword, begin_node, PM_RESCUES_BEGIN, (uint16_t) (depth + 1));
-            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_BEGIN_TERM);
+            expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_BEGIN_TERM, &begin_keyword);
 
             begin_node->base.location.end = parser->previous.end;
             pm_begin_node_end_keyword_set(begin_node, &parser->previous);
@@ -18438,7 +18459,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             pm_token_t opening = parser->previous;
             pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_PREEXE, (uint16_t) (depth + 1));
 
-            expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_BEGIN_UPCASE_TERM);
+            expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_BEGIN_UPCASE_TERM, &opening);
             pm_context_t context = parser->current_context->context;
             if ((context != PM_CONTEXT_MAIN) && (context != PM_CONTEXT_PREEXE)) {
                 pm_parser_err_token(parser, &keyword, PM_ERR_BEGIN_UPCASE_TOPLEVEL);
@@ -18568,7 +18589,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                     parser_warn_indentation_mismatch(parser, opening_newline_index, &class_keyword, false, false);
                 }
 
-                expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CLASS_TERM);
+                expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CLASS_TERM, &class_keyword);
 
                 pm_constant_id_list_t locals;
                 pm_locals_order(parser, &parser->current_scope->locals, &locals, false);
@@ -18626,7 +18647,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                 parser_warn_indentation_mismatch(parser, opening_newline_index, &class_keyword, false, false);
             }
 
-            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CLASS_TERM);
+            expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CLASS_TERM, &class_keyword);
 
             if (context_def_p(parser)) {
                 pm_parser_err_token(parser, &class_keyword, PM_ERR_CLASS_IN_METHOD);
@@ -18936,7 +18957,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                 pm_accepts_block_stack_pop(parser);
                 pm_do_loop_stack_pop(parser);
 
-                expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_DEF_TERM);
+                expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_DEF_TERM, &def_keyword);
                 end_keyword = parser->previous;
             }
 
@@ -19030,7 +19051,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             pm_token_t opening = parser->previous;
             pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_POSTEXE, (uint16_t) (depth + 1));
 
-            expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_END_UPCASE_TERM);
+            expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_END_UPCASE_TERM, &opening);
             return UP(pm_post_execution_node_create(parser, &keyword, &opening, statements, &parser->previous));
         }
         case PM_TOKEN_KEYWORD_FALSE:
@@ -19094,7 +19115,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             }
 
             parser_warn_indentation_mismatch(parser, opening_newline_index, &for_keyword, false, false);
-            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_FOR_TERM);
+            expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_FOR_TERM, &for_keyword);
 
             return UP(pm_for_node_create(parser, index, collection, statements, &for_keyword, &in_keyword, &do_keyword, &parser->previous));
         }
@@ -19245,7 +19266,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             pm_locals_order(parser, &parser->current_scope->locals, &locals, false);
 
             pm_parser_scope_pop(parser);
-            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_MODULE_TERM);
+            expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_MODULE_TERM, &module_keyword);
 
             if (context_def_p(parser)) {
                 pm_parser_err_token(parser, &module_keyword, PM_ERR_MODULE_IN_METHOD);
@@ -19311,7 +19332,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             }
 
             parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, false, false);
-            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_UNTIL_TERM);
+            expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_UNTIL_TERM, &keyword);
 
             return UP(pm_until_node_create(parser, &keyword, &do_keyword, &parser->previous, predicate, statements, 0));
         }
@@ -19345,7 +19366,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
             }
 
             parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, false, false);
-            expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_WHILE_TERM);
+            expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_WHILE_TERM, &keyword);
 
             return UP(pm_while_node_create(parser, &keyword, &do_keyword, &parser->previous, predicate, statements, 0));
         }
@@ -20091,7 +20112,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                 }
 
                 parser_warn_indentation_mismatch(parser, opening_newline_index, &operator, false, false);
-                expect1(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_LAMBDA_TERM_BRACE);
+                expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_LAMBDA_TERM_BRACE, &opening);
             } else {
                 expect1(parser, PM_TOKEN_KEYWORD_DO, PM_ERR_LAMBDA_OPEN);
                 opening = parser->previous;
@@ -20109,7 +20130,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                     parser_warn_indentation_mismatch(parser, opening_newline_index, &operator, false, false);
                 }
 
-                expect1(parser, PM_TOKEN_KEYWORD_END, PM_ERR_LAMBDA_TERM_END);
+                expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_LAMBDA_TERM_END, &operator);
             }
 
             pm_constant_id_list_t locals;

data/vendor/prism/templates/java/org/prism/Loader.java.erb

@@ -101,7 +101,7 @@ public class Loader {
         expect((byte) 'M', "incorrect prism header");
 
         expect((byte) 1, "prism major version does not match");
-        expect((byte) 7, "prism minor version does not match");
+        expect((byte) 8, "prism minor version does not match");
         expect((byte) 0, "prism patch version does not match");
 
         expect((byte) 1, "Loader.java requires no location fields in the serialized output");

data/vendor/prism/templates/javascript/src/deserialize.js.erb

@@ -1,7 +1,7 @@
 import * as nodes from "./nodes.js";
 
 const MAJOR_VERSION = 1;
-const MINOR_VERSION = 7;
+const MINOR_VERSION = 8;
 const PATCH_VERSION = 0;
 
 // The DataView getFloat64 function takes an optional second argument that

data/vendor/prism/templates/lib/prism/compiler.rb.erb

@@ -29,14 +29,14 @@ module Prism
 
     # Visit the child nodes of the given node.
     def visit_child_nodes(node)
-      node.compact_child_nodes.map { |node| node.accept(self) }
+      node.each_child_node.map { |node| node.accept(self) }
     end
 
     <%- nodes.each_with_index do |node, index| -%>
 <%= "\n" if index != 0 -%>
     # Compile a <%= node.name %> node
     def visit_<%= node.human %>(node)
-      node.compact_child_nodes.map { |node| node.accept(self) }
+      node.each_child_node.map { |node| node.accept(self) }
     end
     <%- end -%>
   end

data/vendor/prism/templates/lib/prism/node.rb.erb

@@ -187,7 +187,7 @@ module Prism
       while (node = queue.shift)
         result << node
 
-        node.compact_child_nodes.each do |child_node|
+        node.each_child_node do |child_node|
           child_location = child_node.location
 
           start_line = child_location.start_line
@@ -259,6 +259,13 @@ module Prism
 
     alias deconstruct child_nodes
 
+    # With a block given, yields each child node. Without a block, returns
+    # an enumerator that contains each child node. Excludes any `nil`s in
+    # the place of optional nodes that were not present.
+    def each_child_node
+      raise NoMethodError, "undefined method `each_child_node' for #{inspect}"
+    end
+
     # Returns an array of child nodes, excluding any `nil`s in the place of
     # optional nodes that were not present.
     def compact_child_nodes
@@ -335,6 +342,22 @@ module Prism
       }.compact.join(", ") %>]
     end
 
+    # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
+    def each_child_node
+      return to_enum(:each_child_node) unless block_given?
+
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Prism::Template::NodeField -%>
+      yield <%= field.name %>
+      <%- when Prism::Template::OptionalNodeField -%>
+      yield <%= field.name %> if <%= field.name %>
+      <%- when Prism::Template::NodeListField -%>
+      <%= field.name %>.each { |node| yield node }
+      <%- end -%>
+      <%- end -%>
+    end
+
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       <%- if node.fields.any? { |field| field.is_a?(Prism::Template::OptionalNodeField) } -%>

data/vendor/prism/templates/lib/prism/serialize.rb.erb

@@ -10,7 +10,7 @@ module Prism
 
     # The minor version of prism that we are expecting to find in the serialized
     # strings.
-    MINOR_VERSION = 7
+    MINOR_VERSION = 8
 
     # The patch version of prism that we are expecting to find in the serialized
     # strings.

data/vendor/prism/templates/lib/prism/visitor.rb.erb

@@ -20,7 +20,7 @@ module Prism
     # Visits the child nodes of `node` by calling `accept` on each one.
     def visit_child_nodes(node)
       # @type self: _Visitor
-      node.compact_child_nodes.each { |node| node.accept(self) }
+      node.each_child_node { |node| node.accept(self) }
     end
   end
 
@@ -48,7 +48,7 @@ module Prism
 <%= "\n" if index != 0 -%>
     # Visit a <%= node.name %> node
     def visit_<%= node.human %>(node)
-      node.compact_child_nodes.each { |node| node.accept(self) }
+      node.each_child_node { |node| node.accept(self) }
     end
     <%- end -%>
   end

data/vendor/prism/templates/sig/prism/node.rbs.erb

@@ -12,6 +12,7 @@ module Prism
     def child_nodes: () -> Array[Prism::node?]
     def comment_targets: () -> Array[Prism::node | Location]
     def compact_child_nodes: () -> Array[Prism::node]
+    def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
     def self.fields: () -> Array[Prism::Reflection::Field]
     def type: () -> Symbol
     def self.type: () -> Symbol

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.8.8
 platform: ruby
 authors:
 - Marco Roth
@@ -323,7 +323,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Powerful and seamless HTML-aware ERB parsing and tooling.
 test_files: []