prism 1.5.1 → 1.7.0

data/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
      *
@@ -2638,7 +2661,7 @@ typedef struct pm_case_node {
      * Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
      *
      *     case true; when false; end
-     *     ^^^^
+     *          ^^^^
      */
     struct pm_node *predicate;
 
@@ -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;
 
@@ -7990,6 +8024,8 @@ typedef enum pm_arguments_node_flags {
 
     /** if the arguments contain multiple splats */
     PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS = 64,
+
+    PM_ARGUMENTS_NODE_FLAGS_LAST,
 } pm_arguments_node_flags_t;
 
 /**
@@ -7998,6 +8034,8 @@ typedef enum pm_arguments_node_flags {
 typedef enum pm_array_node_flags {
     /** if array contains splat nodes */
     PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT = 4,
+
+    PM_ARRAY_NODE_FLAGS_LAST,
 } pm_array_node_flags_t;
 
 /**
@@ -8015,6 +8053,8 @@ typedef enum pm_call_node_flags {
 
     /** a call that ignores method visibility */
     PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY = 32,
+
+    PM_CALL_NODE_FLAGS_LAST,
 } pm_call_node_flags_t;
 
 /**
@@ -8026,6 +8066,8 @@ typedef enum pm_encoding_flags {
 
     /** internal bytes forced the encoding to binary */
     PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING = 8,
+
+    PM_ENCODING_FLAGS_LAST,
 } pm_encoding_flags_t;
 
 /**
@@ -8043,6 +8085,8 @@ typedef enum pm_integer_base_flags {
 
     /** 0x prefix */
     PM_INTEGER_BASE_FLAGS_HEXADECIMAL = 32,
+
+    PM_INTEGER_BASE_FLAGS_LAST,
 } pm_integer_base_flags_t;
 
 /**
@@ -8054,6 +8098,8 @@ typedef enum pm_interpolated_string_node_flags {
 
     /** mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` */
     PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE = 8,
+
+    PM_INTERPOLATED_STRING_NODE_FLAGS_LAST,
 } pm_interpolated_string_node_flags_t;
 
 /**
@@ -8062,6 +8108,8 @@ typedef enum pm_interpolated_string_node_flags {
 typedef enum pm_keyword_hash_node_flags {
     /** a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments */
     PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS = 4,
+
+    PM_KEYWORD_HASH_NODE_FLAGS_LAST,
 } pm_keyword_hash_node_flags_t;
 
 /**
@@ -8070,6 +8118,8 @@ typedef enum pm_keyword_hash_node_flags {
 typedef enum pm_loop_flags {
     /** a loop after a begin statement, so the body is executed first before the condition */
     PM_LOOP_FLAGS_BEGIN_MODIFIER = 4,
+
+    PM_LOOP_FLAGS_LAST,
 } pm_loop_flags_t;
 
 /**
@@ -8078,6 +8128,8 @@ typedef enum pm_loop_flags {
 typedef enum pm_parameter_flags {
     /** a parameter name that has been repeated in the method signature */
     PM_PARAMETER_FLAGS_REPEATED_PARAMETER = 4,
+
+    PM_PARAMETER_FLAGS_LAST,
 } pm_parameter_flags_t;
 
 /**
@@ -8086,6 +8138,8 @@ typedef enum pm_parameter_flags {
 typedef enum pm_parentheses_node_flags {
     /** parentheses that contain multiple potentially void statements */
     PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS = 4,
+
+    PM_PARENTHESES_NODE_FLAGS_LAST,
 } pm_parentheses_node_flags_t;
 
 /**
@@ -8094,6 +8148,8 @@ typedef enum pm_parentheses_node_flags {
 typedef enum pm_range_flags {
     /** ... operator */
     PM_RANGE_FLAGS_EXCLUDE_END = 4,
+
+    PM_RANGE_FLAGS_LAST,
 } pm_range_flags_t;
 
 /**
@@ -8132,6 +8188,8 @@ typedef enum pm_regular_expression_flags {
 
     /** internal bytes forced the encoding to US-ASCII */
     PM_REGULAR_EXPRESSION_FLAGS_FORCED_US_ASCII_ENCODING = 4096,
+
+    PM_REGULAR_EXPRESSION_FLAGS_LAST,
 } pm_regular_expression_flags_t;
 
 /**
@@ -8146,6 +8204,8 @@ typedef enum pm_shareable_constant_node_flags {
 
     /** constant writes that should be modified with shareable constant value experimental copy */
     PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY = 16,
+
+    PM_SHAREABLE_CONSTANT_NODE_FLAGS_LAST,
 } pm_shareable_constant_node_flags_t;
 
 /**
@@ -8163,6 +8223,8 @@ typedef enum pm_string_flags {
 
     /** mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal` */
     PM_STRING_FLAGS_MUTABLE = 32,
+
+    PM_STRING_FLAGS_LAST,
 } pm_string_flags_t;
 
 /**
@@ -8177,6 +8239,8 @@ typedef enum pm_symbol_flags {
 
     /** internal bytes forced the encoding to US-ASCII */
     PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING = 16,
+
+    PM_SYMBOL_FLAGS_LAST,
 } pm_symbol_flags_t;
 
 /**

data/include/prism/diagnostic.h

@@ -91,6 +91,7 @@ typedef enum {
     PM_ERR_CONDITIONAL_WHILE_PREDICATE,
     PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT,
     PM_ERR_DEF_ENDLESS,
+    PM_ERR_DEF_ENDLESS_PARAMETERS,
     PM_ERR_DEF_ENDLESS_SETTER,
     PM_ERR_DEF_NAME,
     PM_ERR_DEF_PARAMS_TERM,
@@ -249,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,
@@ -310,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/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/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/include/prism/version.h

@@ -14,16 +14,16 @@
 /**
  * The minor version of the Prism library as an int.
  */
-#define PRISM_VERSION_MINOR 5
+#define PRISM_VERSION_MINOR 7
 
 /**
  * The patch version of the Prism library as an int.
  */
-#define PRISM_VERSION_PATCH 1
+#define PRISM_VERSION_PATCH 0
 
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "1.5.1"
+#define PRISM_VERSION "1.7.0"
 
 #endif

data/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).
  *

data/lib/prism/dot_visitor.rb

@@ -724,6 +724,11 @@ module Prism
         table.field("closing_loc", location_inspect(closing_loc))
       end
 
+      # equal_loc
+      unless (equal_loc = node.equal_loc).nil?
+        table.field("equal_loc", location_inspect(equal_loc))
+      end
+
       # block
       unless (block = node.block).nil?
         table.field("block", port: true)

data/lib/prism/dsl.rb

@@ -167,8 +167,8 @@ module Prism
     end
 
     # Create a new CallNode node.
-    def call_node(source: default_source, node_id: 0, location: default_location, flags: 0, receiver: nil, call_operator_loc: nil, name: :"", message_loc: nil, opening_loc: nil, arguments: nil, closing_loc: nil, block: nil)
-      CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block)
+    def call_node(source: default_source, node_id: 0, location: default_location, flags: 0, receiver: nil, call_operator_loc: nil, name: :"", message_loc: nil, opening_loc: nil, arguments: nil, closing_loc: nil, equal_loc: nil, block: nil)
+      CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, equal_loc, block)
     end
 
     # Create a new CallOperatorWriteNode node.

data/lib/prism/ffi.rb

@@ -423,17 +423,25 @@ module Prism
 
     # Return the value that should be dumped for the version option.
     def dump_options_version(version)
-      case version
+      current = version == "current"
+
+      case current ? RUBY_VERSION : version
       when nil, "latest"
         0 # Handled in pm_parser_init
       when /\A3\.3(\.\d+)?\z/
         1
       when /\A3\.4(\.\d+)?\z/
         2
-      when /\A3\.5(\.\d+)?\z/
+      when /\A3\.5(\.\d+)?\z/, /\A4\.0(\.\d+)?\z/
         3
+      when /\A4\.1(\.\d+)?\z/
+        4
       else
-        raise ArgumentError, "invalid version: #{version}"
+        if current
+          raise CurrentVersionError, RUBY_VERSION
+        else
+          raise ArgumentError, "invalid version: #{version}"
+        end
       end
     end
 

data/lib/prism/inspect_visitor.rb

@@ -402,6 +402,7 @@ module Prism
         commands << [arguments, "#{indent}│   "]
       end
       commands << ["├── closing_loc: #{inspect_location(node.closing_loc)}\n", indent]
+      commands << ["├── equal_loc: #{inspect_location(node.equal_loc)}\n", indent]
       if (block = node.block).nil?
         commands << ["└── block: ∅\n", indent]
       else

data/lib/prism/node.rb

@@ -2605,7 +2605,7 @@ module Prism
   #     ^^^^^^^^
   class CallNode < Node
     # Initialize a new CallNode node.
-    def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block)
+    def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, equal_loc, block)
       @source = source
       @node_id = node_id
       @location = location
@@ -2617,6 +2617,7 @@ module Prism
       @opening_loc = opening_loc
       @arguments = arguments
       @closing_loc = closing_loc
+      @equal_loc = equal_loc
       @block = block
     end
 
@@ -2641,20 +2642,20 @@ module Prism
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, *block] #: Array[Prism::node | Location]
+      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, *equal_loc, *block] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
-    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block)
-      CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block)
+    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?equal_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
+    def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, equal_loc: self.equal_loc, block: self.block)
+      CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, equal_loc, block)
     end
 
     # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, equal_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
     def deconstruct_keys(keys)
-      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block }
+      { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, equal_loc: equal_loc, block: block }
     end
 
     # def safe_navigation?: () -> bool
@@ -2791,6 +2792,31 @@ module Prism
       repository.enter(node_id, :closing_loc) unless @closing_loc.nil?
     end
 
+    # Represents the location of the equal sign, in the case that this is an attribute write.
+    #
+    #     foo.bar = value
+    #             ^
+    #
+    #     foo[bar] = value
+    #              ^
+    def equal_loc
+      location = @equal_loc
+      case location
+      when nil
+        nil
+      when Location
+        location
+      else
+        @equal_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
+      end
+    end
+
+    # Save the equal_loc location using the given saved source so that
+    # it can be retrieved later.
+    def save_equal_loc(repository)
+      repository.enter(node_id, :equal_loc) unless @equal_loc.nil?
+    end
+
     # Represents the block that is being passed to the method.
     #
     #     foo { |a| a }
@@ -2817,6 +2843,11 @@ module Prism
       closing_loc&.slice
     end
 
+    # def equal: () -> String?
+    def equal
+      equal_loc&.slice
+    end
+
     # def inspect -> String
     def inspect
       InspectVisitor.compose(self)
@@ -2844,6 +2875,7 @@ module Prism
         (opening_loc.nil? == other.opening_loc.nil?) &&
         (arguments === other.arguments) &&
         (closing_loc.nil? == other.closing_loc.nil?) &&
+        (equal_loc.nil? == other.equal_loc.nil?) &&
         (block === other.block)
     end
   end
@@ -3732,7 +3764,7 @@ module Prism
     # Represents the predicate of the case statement. This can be either `nil` or any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
     #     case true; when false; end
-    #     ^^^^
+    #          ^^^^
     attr_reader :predicate
 
     # Represents the conditions of the case statement.
@@ -7536,10 +7568,15 @@ module Prism
     end
   end
 
-  # 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.
   class ForwardingSuperNode < Node
     # Initialize a new ForwardingSuperNode node.
     def initialize(source, node_id, location, flags, block)
@@ -7585,7 +7622,7 @@ module Prism
       { node_id: node_id, location: location, block: block }
     end
 
-    # attr_reader block: BlockNode?
+    # All other arguments are forwarded as normal, except the original block is replaced with the new block.
     attr_reader :block
 
     # def inspect -> String
@@ -10951,7 +10988,7 @@ module Prism
       [*opening_loc, *parts, *closing_loc] #: Array[Prism::node | Location]
     end
 
-    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode], ?closing_loc: Location?) -> InterpolatedStringNode
+    # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], ?closing_loc: Location?) -> InterpolatedStringNode
     def copy(node_id: self.node_id, location: self.location, flags: self.flags, opening_loc: self.opening_loc, parts: self.parts, closing_loc: self.closing_loc)
       InterpolatedStringNode.new(source, node_id, location, flags, opening_loc, parts, closing_loc)
     end
@@ -10959,7 +10996,7 @@ module Prism
     # def deconstruct: () -> Array[Node?]
     alias deconstruct child_nodes
 
-    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode], closing_loc: Location? }
+    # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], closing_loc: Location? }
     def deconstruct_keys(keys)
       { node_id: node_id, location: location, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc }
     end
@@ -10993,7 +11030,7 @@ module Prism
       repository.enter(node_id, :opening_loc) unless @opening_loc.nil?
     end
 
-    # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode]
+    # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode]
     attr_reader :parts
 
     # attr_reader closing_loc: Location?
@@ -17213,6 +17250,8 @@ module Prism
   #
   #     super foo, bar
   #     ^^^^^^^^^^^^^^
+  #
+  # If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead.
   class SuperNode < Node
     # Initialize a new SuperNode node.
     def initialize(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc, block)
@@ -17295,7 +17334,7 @@ module Prism
       repository.enter(node_id, :lparen_loc) unless @lparen_loc.nil?
     end
 
-    # attr_reader arguments: ArgumentsNode?
+    # Can be only `nil` when there are empty parentheses, like `super()`.
     attr_reader :arguments
 
     # attr_reader rparen_loc: Location?

data/lib/prism/parse_result.rb

@@ -155,21 +155,8 @@ module Prism
     # Binary search through the offsets to find the line number for the given
     # byte offset.
     def find_line(byte_offset)
-      left = 0
-      right = offsets.length - 1
-
-      while left <= right
-        mid = left + (right - left) / 2
-        return mid if (offset = offsets[mid]) == byte_offset
-
-        if offset < byte_offset
-          left = mid + 1
-        else
-          right = mid - 1
-        end
-      end
-
-      left - 1
+      index = offsets.bsearch_index { |offset| offset > byte_offset } || offsets.length
+      index - 1
     end
   end
 

data/lib/prism/polyfill/scan_byte.rb

@@ -3,7 +3,7 @@
 require "strscan"
 
 # Polyfill for StringScanner#scan_byte, which didn't exist until Ruby 3.4.
-if !(StringScanner.instance_methods.include?(:scan_byte))
+if !(StringScanner.method_defined?(:scan_byte))
   StringScanner.include(
     Module.new {
       def scan_byte # :nodoc: