herb 0.8.4-x86-linux-gnu → 0.8.6-x86-linux-gnu

data/src/include/analyzed_ruby.h

@@ -11,24 +11,25 @@ typedef struct ANALYZED_RUBY_STRUCT {
   pm_node_t* root;
   bool valid;
   bool parsed;
-  bool has_if_node;
-  bool has_elsif_node;
-  bool has_else_node;
-  bool has_end;
-  bool has_block_closing;
-  bool has_block_node;
-  bool has_case_node;
-  bool has_case_match_node;
-  bool has_when_node;
-  bool has_in_node;
-  bool has_for_node;
-  bool has_while_node;
-  bool has_until_node;
-  bool has_begin_node;
-  bool has_rescue_node;
-  bool has_ensure_node;
-  bool has_unless_node;
-  bool has_yield_node;
+  int if_node_count;
+  int elsif_node_count;
+  int else_node_count;
+  int end_count;
+  int block_closing_count;
+  int block_node_count;
+  int case_node_count;
+  int case_match_node_count;
+  int when_node_count;
+  int in_node_count;
+  int for_node_count;
+  int while_node_count;
+  int until_node_count;
+  int begin_node_count;
+  int rescue_node_count;
+  int ensure_node_count;
+  int unless_node_count;
+  int yield_node_count;
+  int unclosed_control_flow_count;
 } analyzed_ruby_T;
 
 analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);

data/src/include/errors.h

@@ -23,6 +23,7 @@ typedef enum {
   RUBY_PARSE_ERROR,
   ERB_CONTROL_FLOW_SCOPE_ERROR,
   MISSINGERB_END_TAG_ERROR,
+  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -96,6 +97,11 @@ typedef struct {
   const char* keyword;
 } MISSINGERB_END_TAG_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  /* no additional fields */
+} ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end);
 void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end);
@@ -118,6 +124,8 @@ ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* ke
 void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
 MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end);
 void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
+ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end);
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 

data/src/include/util/hb_narray.h

@@ -0,0 +1,29 @@
+#ifndef HERB_NARRAY_H
+#define HERB_NARRAY_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef struct HB_NARRAY_STRUCT {
+  uint8_t* items;
+  size_t item_size;
+  size_t size;
+  size_t capacity;
+} hb_narray_T;
+
+void hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacity);
+#define hb_narray_pointer_init(array, initial_capacity) (hb_narray_init(array, sizeof(void*), initial_capacity))
+
+void* hb_narray_get(const hb_narray_T* array, size_t index);
+void* hb_narray_first(hb_narray_T* array);
+void* hb_narray_last(hb_narray_T* array);
+
+void hb_narray_append(hb_narray_T* array, void* item);
+void hb_narray_remove(hb_narray_T* array, size_t index);
+void hb_narray_deinit(hb_narray_T* array);
+
+#define hb_narray_push(array, item) (hb_narray_append(array, item))
+bool hb_narray_pop(hb_narray_T* array, void* item);
+
+#endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.4"
+#define HERB_VERSION "0.8.6"
 
 #endif

data/src/lexer.c

@@ -185,8 +185,8 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 // ===== ERB Parsing
 
 static token_T* lexer_parse_erb_open(lexer_T* lexer) {
-  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="), hb_string("<%#"),
-                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%") };
+  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="),       hb_string("<%#"),
+                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%graphql"), hb_string("<%") };
 
   lexer->state = STATE_ERB_CONTENT;
 
@@ -278,7 +278,7 @@ token_T* lexer_next_token(lexer_T* lexer) {
         return lexer_advance_with_next(lexer, strlen("<![CDATA["), TOKEN_CDATA_START);
       }
 
-      if (isalnum(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
+      if (isalpha(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
 
       if (lexer_peek_for_html_comment_start(lexer, 0)) {
         return lexer_advance_with(lexer, hb_string("<!--"), TOKEN_HTML_COMMENT_START);

data/src/parser.c

@@ -1115,7 +1115,9 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
           TOKEN_DASH,
           TOKEN_EQUALS,
           TOKEN_EXCLAMATION,
+          TOKEN_HTML_TAG_END,
           TOKEN_IDENTIFIER,
+          TOKEN_LT,
           TOKEN_NBSP,
           TOKEN_NEWLINE,
           TOKEN_PERCENT,
@@ -1149,11 +1151,11 @@ static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_st
     if (node->type == AST_HTML_OPEN_TAG_NODE) {
       AST_HTML_OPEN_TAG_NODE_T* open = (AST_HTML_OPEN_TAG_NODE_T*) node;
 
-      if (hb_string_equals(hb_string(open->tag_name->value), tag_name)) { depth++; }
+      if (hb_string_equals_case_insensitive(hb_string(open->tag_name->value), tag_name)) { depth++; }
     } else if (node->type == AST_HTML_CLOSE_TAG_NODE) {
       AST_HTML_CLOSE_TAG_NODE_T* close = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
-      if (hb_string_equals(hb_string(close->tag_name->value), tag_name)) {
+      if (hb_string_equals_case_insensitive(hb_string(close->tag_name->value), tag_name)) {
         if (depth == 0) { return i; }
         depth--;
       }

data/src/parser_helpers.c

@@ -24,7 +24,7 @@ bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
   token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
-  return hb_string_equals(hb_string(top_token->value), tag_name);
+  return hb_string_equals_case_insensitive(hb_string(top_token->value), tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
@@ -49,7 +49,7 @@ bool parser_in_svg_context(const parser_T* parser) {
 
     if (tag && tag->value) {
       hb_string_T tag_value_string = hb_string(tag->value);
-      if (hb_string_equals(tag_value_string, hb_string("svg"))) { return true; }
+      if (hb_string_equals_case_insensitive(tag_value_string, hb_string("svg"))) { return true; }
     }
   }
 
@@ -61,8 +61,8 @@ bool parser_in_svg_context(const parser_T* parser) {
 foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return FOREIGN_CONTENT_UNKNOWN; }
 
-  if (hb_string_equals(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
-  if (hb_string_equals(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
+  if (hb_string_equals_case_insensitive(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
+  if (hb_string_equals_case_insensitive(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
 
   return FOREIGN_CONTENT_UNKNOWN;
 }
@@ -217,5 +217,5 @@ bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_t
 
   if (hb_string_is_empty(tag_name) || hb_string_is_empty(expected_tag_name)) { return false; }
 
-  return hb_string_equals(expected_tag_name, tag_name);
+  return hb_string_equals_case_insensitive(expected_tag_name, tag_name);
 }

data/src/util/hb_narray.c

@@ -0,0 +1,75 @@
+#include "../include/util/hb_narray.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <string.h>
+
+void hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacity) {
+  assert(initial_capacity != 0);
+
+  array->item_size = item_size;
+  array->capacity = initial_capacity;
+  array->size = 0;
+  array->items = malloc(array->capacity * array->item_size);
+}
+
+void hb_narray_append(hb_narray_T* array, void* item) {
+  if (array->size + 1 > array->capacity) {
+    array->capacity *= 2;
+    void* new_buffer = realloc(array->items, array->capacity * array->item_size);
+    assert(new_buffer != NULL);
+    array->items = new_buffer;
+  }
+
+  memcpy(array->items + (array->size * array->item_size), item, array->item_size);
+  array->size += 1;
+}
+
+static inline uint8_t* hb_narray_memory_position(const hb_narray_T* array, size_t index) {
+  return array->items + (array->item_size * index);
+}
+
+void hb_narray_remove(hb_narray_T* array, size_t index) {
+  assert(index < array->size);
+
+  if (array->size - 1 > index) {
+    size_t elements_to_shift = (array->size - 1) - index;
+    size_t bytes_to_shift = array->item_size * elements_to_shift;
+
+    memcpy(hb_narray_memory_position(array, index), hb_narray_memory_position(array, index + 1), bytes_to_shift);
+  }
+
+  array->size -= 1;
+}
+
+void* hb_narray_get(const hb_narray_T* array, size_t index) {
+  assert(index < array->size);
+
+  return hb_narray_memory_position(array, index);
+}
+
+void* hb_narray_first(hb_narray_T* array) {
+  if (array->size == 0) { return NULL; }
+
+  return hb_narray_get(array, 0);
+}
+
+void* hb_narray_last(hb_narray_T* array) {
+  if (array->size == 0) { return NULL; }
+  return hb_narray_get(array, array->size - 1);
+}
+
+bool hb_narray_pop(hb_narray_T* array, void* item) {
+  if (array->size == 0) { return false; }
+  memcpy(item, hb_narray_last(array), array->item_size);
+  array->size -= 1;
+
+  return true;
+}
+
+void hb_narray_deinit(hb_narray_T* array) {
+  array->item_size = 0;
+  array->capacity = 0;
+  array->size = 0;
+  free(array->items);
+}

data/templates/lib/herb/errors.rb.erb

@@ -46,6 +46,7 @@ module Herb
     <%- errors.each do |error| -%>
     class <%= error.name -%> < Error
       include Colors
+      <%- if error.fields.any? -%>
 
       <%- error.fields.each do |field| -%>
       attr_reader :<%= field.name %> #: <%= field.ruby_type %>
@@ -54,25 +55,27 @@ module Herb
       #: (<%= [*base_arguments.map(&:last), *error.fields.map(&:ruby_type)].join(", ") %>) -> void
       def initialize(<%= [*base_arguments.map(&:first), *error.fields.map(&:name)].join(", ") %>)
         super(<%= base_arguments.map(&:first).join(", ") %>)
-
         <%- error.fields.each do |field| -%>
         @<%= field.name %> = <%= field.name %>
         <%- end -%>
       end
+      <%- end -%>
 
       #: () -> String
       def inspect
         tree_inspect.rstrip.gsub(/\s+$/, "")
       end
+      <%- if error.fields.any? -%>
 
       #: () -> serialized_<%= error.human %>
       def to_hash
-        super.merge({
-          <%- error.fields.each do |field| -%>
-          <%= field.name %>: <%= field.name %>,
+        super.merge(
+          <%- error.fields.each_with_index do |field, index| -%>
+          <%= field.name %>: <%= field.name %><%= index < error.fields.size - 1 ? "," : "" %>
           <%- end -%>
-        }) #: Herb::serialized_<%= error.human %>
+        ) #: Herb::serialized_<%= error.human %>
       end
+      <%- end -%>
 
       #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
       def tree_inspect(indent: 0, depth: 0, depth_limit: 25)

data/templates/src/ast_pretty_print.c.erb

@@ -1,3 +1,4 @@
+#include "include/analyze_helpers.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
@@ -62,21 +63,21 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
       <%- when Herb::Template::AnalyzedRubyField -%>
       if (<%= node.human %>-><%= field.name %>) {
-        pretty_print_boolean_property(hb_string("if_node"), <%= node.human %>-><%= field.name %>->has_if_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("elsif_node"), <%= node.human %>-><%= field.name %>->has_elsif_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("else_node"), <%= node.human %>-><%= field.name %>->has_else_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("end"), <%= node.human %>-><%= field.name %>->has_end, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("block_node"), <%= node.human %>-><%= field.name %>->has_block_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("block_closing"), <%= node.human %>-><%= field.name %>->has_block_closing, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("case_node"), <%= node.human %>-><%= field.name %>->has_case_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("when_node"), <%= node.human %>-><%= field.name %>->has_when_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("for_node"), <%= node.human %>-><%= field.name %>->has_for_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("while_node"), <%= node.human %>-><%= field.name %>->has_while_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("until_node"), <%= node.human %>-><%= field.name %>->has_until_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("begin_node"), <%= node.human %>-><%= field.name %>->has_begin_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("rescue_node"), <%= node.human %>-><%= field.name %>->has_rescue_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("ensure_node"), <%= node.human %>-><%= field.name %>->has_ensure_node, indent, relative_indent,  <%= last %>, buffer);
-        pretty_print_boolean_property(hb_string("unless_node"), <%= node.human %>-><%= field.name %>->has_unless_node, indent, relative_indent,  <%= last %>, buffer);
+        pretty_print_boolean_property(hb_string("if_node"), has_if_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("elsif_node"), has_elsif_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("else_node"), has_else_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("end"), has_end(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_node"), has_block_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_closing"), has_block_closing(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("case_node"), has_case_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("when_node"), has_when_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("for_node"), has_for_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("while_node"), has_while_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("until_node"), has_until_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("begin_node"), has_begin_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("rescue_node"), has_rescue_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("ensure_node"), has_ensure_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("unless_node"), has_unless_node(<%= node.human %>-><%= field.name %>), indent, relative_indent, false, buffer);
       } else {
       pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
         hb_buffer_append(buffer, " ∅\n");

data/vendor/prism/config.yml

@@ -219,6 +219,7 @@ errors:
   - PARAMETER_WILD_LOOSE_COMMA
   - PATTERN_ARRAY_MULTIPLE_RESTS
   - PATTERN_CAPTURE_DUPLICATE
+  - PATTERN_CAPTURE_IN_ALTERNATIVE
   - PATTERN_EXPRESSION_AFTER_BRACKET
   - PATTERN_EXPRESSION_AFTER_COMMA
   - PATTERN_EXPRESSION_AFTER_HROCKET
@@ -280,6 +281,7 @@ errors:
   - UNEXPECTED_INDEX_KEYWORDS
   - UNEXPECTED_LABEL
   - UNEXPECTED_MULTI_WRITE
+  - UNEXPECTED_PARAMETER_DEFAULT_VALUE
   - UNEXPECTED_RANGE_OPERATOR
   - UNEXPECTED_SAFE_NAVIGATION
   - UNEXPECTED_TOKEN_CLOSE_CONTEXT
@@ -356,6 +358,8 @@ tokens:
     comment: "a newline character outside of other tokens"
   - name: PARENTHESIS_RIGHT
     comment: ")"
+  - name: PIPE
+    comment: "|"
   - name: SEMICOLON
     comment: ";"
   # Tokens from here on are not used for lookup, and can be in any order.
@@ -589,8 +593,6 @@ tokens:
     comment: "%I"
   - name: PERCENT_UPPER_W
     comment: "%W"
-  - name: PIPE
-    comment: "|"
   - name: PIPE_EQUAL
     comment: "|="
   - name: PIPE_PIPE
@@ -1515,6 +1517,16 @@ nodes:
 
               foo(bar)
                      ^
+      - name: equal_loc
+        type: location?
+        comment: |
+          Represents the location of the equal sign, in the case that this is an attribute write.
+
+              foo.bar = value
+                      ^
+
+              foo[bar] = value
+                       ^
       - name: block
         type: node?
         kind:
@@ -2616,11 +2628,18 @@ nodes:
       - name: block
         type: node?
         kind: BlockNode
+        comment: |
+          All other arguments are forwarded as normal, except the original block is replaced with the new block.
     comment: |
-      Represents the use of the `super` keyword without parentheses or arguments.
+      Represents the use of the `super` keyword without parentheses or arguments, but which might have a block.
 
           super
           ^^^^^
+
+          super { 123 }
+          ^^^^^^^^^^^^^
+
+      If it has any other arguments, it would be a `SuperNode` instead.
   - name: GlobalVariableAndWriteNode
     fields:
       - name: name
@@ -3287,6 +3306,9 @@ nodes:
           - EmbeddedVariableNode
           - InterpolatedStringNode # `"a" "#{b}"`
           - on error: XStringNode # `<<`FOO` "bar"
+          - on error: InterpolatedXStringNode
+          - on error: SymbolNode
+          - on error: InterpolatedSymbolNode
       - name: closing_loc
         type: location?
     newline: parts
@@ -4496,6 +4518,7 @@ nodes:
       - name: arguments
         type: node?
         kind: ArgumentsNode
+        comment: "Can be only `nil` when there are empty parentheses, like `super()`."
       - name: rparen_loc
         type: location?
       - name: block
@@ -4511,6 +4534,8 @@ nodes:
 
           super foo, bar
           ^^^^^^^^^^^^^^
+
+      If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead.
   - name: SymbolNode
     flags: SymbolFlags
     fields:

data/vendor/prism/include/prism/ast.h

@@ -76,6 +76,9 @@ typedef enum pm_token_type {
     /** ) */
     PM_TOKEN_PARENTHESIS_RIGHT,
 
+    /** | */
+    PM_TOKEN_PIPE,
+
     /** ; */
     PM_TOKEN_SEMICOLON,
 
@@ -424,9 +427,6 @@ typedef enum pm_token_type {
     /** %W */
     PM_TOKEN_PERCENT_UPPER_W,
 
-    /** | */
-    PM_TOKEN_PIPE,
-
     /** |= */
     PM_TOKEN_PIPE_EQUAL,
 
@@ -1050,22 +1050,6 @@ typedef uint16_t pm_node_flags_t;
 static const pm_node_flags_t PM_NODE_FLAG_NEWLINE = 0x1;
 static const pm_node_flags_t PM_NODE_FLAG_STATIC_LITERAL = 0x2;
 
-/**
- * Cast the type to an enum to allow the compiler to provide exhaustiveness
- * checking.
- */
-#define PM_NODE_TYPE(node) ((enum pm_node_type) (node)->type)
-
-/**
- * Return true if the type of the given node matches the given type.
- */
-#define PM_NODE_TYPE_P(node, type) (PM_NODE_TYPE(node) == (type))
-
-/**
- * Return true if the given flag is set on the given node.
- */
-#define PM_NODE_FLAG_P(node, flag) ((((pm_node_t *)(node))->flags & (flag)) != 0)
-
 /**
  * This is the base structure that represents a node in the syntax tree. It is
  * embedded into every node type.
@@ -1096,6 +1080,32 @@ typedef struct pm_node {
     pm_location_t location;
 } pm_node_t;
 
+/**
+ * Cast the given node to the base pm_node_t type.
+ */
+#define PM_NODE_UPCAST(node_) ((pm_node_t *) (node_))
+
+/**
+ * Cast the type to an enum to allow the compiler to provide exhaustiveness
+ * checking.
+ */
+#define PM_NODE_TYPE(node_) ((enum pm_node_type) (node_)->type)
+
+/**
+ * Return true if the type of the given node matches the given type.
+ */
+#define PM_NODE_TYPE_P(node_, type_) (PM_NODE_TYPE(node_) == (type_))
+
+/**
+ * Return the flags associated with the given node.
+ */
+#define PM_NODE_FLAGS(node_) (PM_NODE_UPCAST(node_)->flags)
+
+/**
+ * Return true if the given flag is set on the given node.
+ */
+#define PM_NODE_FLAG_P(node_, flag_) ((PM_NODE_FLAGS(node_) & (flag_)) != 0)
+
 /**
  * AliasGlobalVariableNode
  *
@@ -2214,6 +2224,19 @@ typedef struct pm_call_node {
      */
     pm_location_t closing_loc;
 
+    /**
+     * CallNode#equal_loc
+     *
+     * Represents the location of the equal sign, in the case that this is an attribute write.
+     *
+     *     foo.bar = value
+     *             ^
+     *
+     *     foo[bar] = value
+     *              ^
+     */
+    pm_location_t equal_loc;
+
     /**
      * CallNode#block
      *
@@ -4084,11 +4107,16 @@ typedef struct pm_forwarding_parameter_node {
 /**
  * ForwardingSuperNode
  *
- * Represents the use of the `super` keyword without parentheses or arguments.
+ * Represents the use of the `super` keyword without parentheses or arguments, but which might have a block.
  *
  *     super
  *     ^^^^^
  *
+ *     super { 123 }
+ *     ^^^^^^^^^^^^^
+ *
+ * If it has any other arguments, it would be a `SuperNode` instead.
+ *
  * Type: ::PM_FORWARDING_SUPER_NODE
  *
  * @extends pm_node_t
@@ -4100,6 +4128,8 @@ typedef struct pm_forwarding_super_node {
 
     /**
      * ForwardingSuperNode#block
+     *
+     * All other arguments are forwarded as normal, except the original block is replaced with the new block.
      */
     struct pm_block_node *block;
 } pm_forwarding_super_node_t;
@@ -7539,6 +7569,8 @@ typedef struct pm_string_node {
  *     super foo, bar
  *     ^^^^^^^^^^^^^^
  *
+ * If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead.
+ *
  * Type: ::PM_SUPER_NODE
  *
  * @extends pm_node_t
@@ -7560,6 +7592,8 @@ typedef struct pm_super_node {
 
     /**
      * SuperNode#arguments
+     *
+     * Can be only `nil` when there are empty parentheses, like `super()`.
      */
     struct pm_arguments_node *arguments;
 

data/vendor/prism/include/prism/diagnostic.h

@@ -250,6 +250,7 @@ typedef enum {
     PM_ERR_PARAMETER_WILD_LOOSE_COMMA,
     PM_ERR_PATTERN_ARRAY_MULTIPLE_RESTS,
     PM_ERR_PATTERN_CAPTURE_DUPLICATE,
+    PM_ERR_PATTERN_CAPTURE_IN_ALTERNATIVE,
     PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET,
     PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA,
     PM_ERR_PATTERN_EXPRESSION_AFTER_HROCKET,
@@ -311,6 +312,7 @@ typedef enum {
     PM_ERR_UNEXPECTED_INDEX_KEYWORDS,
     PM_ERR_UNEXPECTED_LABEL,
     PM_ERR_UNEXPECTED_MULTI_WRITE,
+    PM_ERR_UNEXPECTED_PARAMETER_DEFAULT_VALUE,
     PM_ERR_UNEXPECTED_RANGE_OPERATOR,
     PM_ERR_UNEXPECTED_SAFE_NAVIGATION,
     PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT,

data/vendor/prism/include/prism/options.h

@@ -91,11 +91,17 @@ typedef enum {
     /** The vendored version of prism in CRuby 3.4.x. */
     PM_OPTIONS_VERSION_CRUBY_3_4 = 2,
 
-    /** The vendored version of prism in CRuby 3.5.x. */
+    /** The vendored version of prism in CRuby 4.0.x. */
     PM_OPTIONS_VERSION_CRUBY_3_5 = 3,
 
+    /** The vendored version of prism in CRuby 4.0.x. */
+    PM_OPTIONS_VERSION_CRUBY_4_0 = 3,
+
+    /** The vendored version of prism in CRuby 4.1.x. */
+    PM_OPTIONS_VERSION_CRUBY_4_1 = 4,
+
     /** The current version of prism. */
-    PM_OPTIONS_VERSION_LATEST = PM_OPTIONS_VERSION_CRUBY_3_5
+    PM_OPTIONS_VERSION_LATEST = PM_OPTIONS_VERSION_CRUBY_4_1
 } pm_options_version_t;
 
 /**

data/vendor/prism/include/prism/parser.h

@@ -299,6 +299,9 @@ typedef enum {
     /** a rescue else statement within a do..end block */
     PM_CONTEXT_BLOCK_ELSE,
 
+    /** expressions in block parameters `foo do |...| end ` */
+    PM_CONTEXT_BLOCK_PARAMETERS,
+
     /** a rescue statement within a do..end block */
     PM_CONTEXT_BLOCK_RESCUE,
 

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 6
+#define PRISM_VERSION_MINOR 7
 
 /**
  * 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.6.0"
+#define PRISM_VERSION "1.7.0"
 
 #endif

data/vendor/prism/include/prism.h

@@ -314,7 +314,7 @@ PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_method_name(const uint
  * dependencies. It is currently being integrated into
  * [CRuby](https://github.com/ruby/ruby),
  * [JRuby](https://github.com/jruby/jruby),
- * [TruffleRuby](https://github.com/oracle/truffleruby),
+ * [TruffleRuby](https://github.com/truffleruby/truffleruby),
  * [Sorbet](https://github.com/sorbet/sorbet), and
  * [Syntax Tree](https://github.com/ruby-syntax-tree/syntax_tree).
  *