@appthreat/atom-parsetools 1.0.16 → 1.1.1

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/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
@@ -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?

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/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
 

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/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:

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism/reflection.rb

@@ -143,7 +143,7 @@ module Prism
       when :call_and_write_node
         [FlagsField.new(:flags, [:safe_navigation?, :variable_call?, :attribute_write?, :ignore_visibility?]), OptionalNodeField.new(:receiver), OptionalLocationField.new(:call_operator_loc), OptionalLocationField.new(:message_loc), ConstantField.new(:read_name), ConstantField.new(:write_name), LocationField.new(:operator_loc), NodeField.new(:value)]
       when :call_node
-        [FlagsField.new(:flags, [:safe_navigation?, :variable_call?, :attribute_write?, :ignore_visibility?]), OptionalNodeField.new(:receiver), OptionalLocationField.new(:call_operator_loc), ConstantField.new(:name), OptionalLocationField.new(:message_loc), OptionalLocationField.new(:opening_loc), OptionalNodeField.new(:arguments), OptionalLocationField.new(:closing_loc), OptionalNodeField.new(:block)]
+        [FlagsField.new(:flags, [:safe_navigation?, :variable_call?, :attribute_write?, :ignore_visibility?]), OptionalNodeField.new(:receiver), OptionalLocationField.new(:call_operator_loc), ConstantField.new(:name), OptionalLocationField.new(:message_loc), OptionalLocationField.new(:opening_loc), OptionalNodeField.new(:arguments), OptionalLocationField.new(:closing_loc), OptionalLocationField.new(:equal_loc), OptionalNodeField.new(:block)]
       when :call_operator_write_node
         [FlagsField.new(:flags, [:safe_navigation?, :variable_call?, :attribute_write?, :ignore_visibility?]), OptionalNodeField.new(:receiver), OptionalLocationField.new(:call_operator_loc), OptionalLocationField.new(:message_loc), ConstantField.new(:read_name), ConstantField.new(:write_name), ConstantField.new(:binary_operator), LocationField.new(:binary_operator_loc), NodeField.new(:value)]
       when :call_or_write_node

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism/serialize.rb

@@ -21,7 +21,7 @@ module Prism
 
     # The minor version of prism that we are expecting to find in the serialized
     # strings.
-    MINOR_VERSION = 6
+    MINOR_VERSION = 7
 
     # The patch version of prism that we are expecting to find in the serialized
     # strings.
@@ -556,6 +556,7 @@ module Prism
         :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,
@@ -617,6 +618,7 @@ module Prism
         :unexpected_index_keywords,
         :unexpected_label,
         :unexpected_multi_write,
+        :unexpected_parameter_default_value,
         :unexpected_range_operator,
         :unexpected_safe_navigation,
         :unexpected_token_close_context,
@@ -879,7 +881,7 @@ module Prism
           when 18 then
             CallAndWriteNode.new(source, node_id, location, load_varuint, load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_optional_location(freeze), load_constant(constant_pool, encoding), load_constant(constant_pool, encoding), load_location(freeze), load_node(constant_pool, encoding, freeze))
           when 19 then
-            CallNode.new(source, node_id, location, load_varuint, load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_constant(constant_pool, encoding), load_optional_location(freeze), load_optional_location(freeze), load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_optional_node(constant_pool, encoding, freeze))
+            CallNode.new(source, node_id, location, load_varuint, load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_constant(constant_pool, encoding), load_optional_location(freeze), load_optional_location(freeze), load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_optional_location(freeze), load_optional_node(constant_pool, encoding, freeze))
           when 20 then
             CallOperatorWriteNode.new(source, node_id, location, load_varuint, load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_optional_location(freeze), load_constant(constant_pool, encoding), load_constant(constant_pool, encoding), load_constant(constant_pool, encoding), load_location(freeze), load_node(constant_pool, encoding, freeze))
           when 21 then
@@ -1287,7 +1289,7 @@ module Prism
             -> (constant_pool, encoding, freeze) {
               node_id = load_varuint
               location = load_location(freeze)
-              value = CallNode.new(source, node_id, location, load_varuint, load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_constant(constant_pool, encoding), load_optional_location(freeze), load_optional_location(freeze), load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_optional_node(constant_pool, encoding, freeze))
+              value = CallNode.new(source, node_id, location, load_varuint, load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_constant(constant_pool, encoding), load_optional_location(freeze), load_optional_location(freeze), load_optional_node(constant_pool, encoding, freeze), load_optional_location(freeze), load_optional_location(freeze), load_optional_node(constant_pool, encoding, freeze))
               value.freeze if freeze
               value
             },
@@ -2239,6 +2241,7 @@ module Prism
       :KEYWORD_WHEN,
       :NEWLINE,
       :PARENTHESIS_RIGHT,
+      :PIPE,
       :SEMICOLON,
       :AMPERSAND,
       :AMPERSAND_AMPERSAND,
@@ -2355,7 +2358,6 @@ module Prism
       :PERCENT_LOWER_X,
       :PERCENT_UPPER_I,
       :PERCENT_UPPER_W,
-      :PIPE,
       :PIPE_EQUAL,
       :PIPE_PIPE,
       :PIPE_PIPE_EQUAL,

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism/translation/parser/compiler.rb

@@ -217,7 +217,7 @@ module Prism
                 rescue_clause.exceptions.any? ? builder.array(nil, visit_all(rescue_clause.exceptions), nil) : nil,
                 token(rescue_clause.operator_loc),
                 visit(rescue_clause.reference),
-                srange_find(find_start_offset, find_end_offset, ";"),
+                srange_semicolon(find_start_offset, find_end_offset),
                 visit(rescue_clause.statements)
               )
             end until (rescue_clause = rescue_clause.subsequent).nil?
@@ -323,7 +323,7 @@ module Prism
                       visit_all(arguments),
                       token(node.closing_loc),
                     ),
-                    srange_find(node.message_loc.end_offset, node.arguments.arguments.last.location.start_offset, "="),
+                    token(node.equal_loc),
                     visit(node.arguments.arguments.last)
                   ),
                   block
@@ -340,7 +340,7 @@ module Prism
             if name.end_with?("=") && !message_loc.slice.end_with?("=") && node.arguments && block.nil?
               builder.assign(
                 builder.attr_asgn(visit(node.receiver), call_operator, token(message_loc)),
-                srange_find(message_loc.end_offset, node.arguments.location.start_offset, "="),
+                token(node.equal_loc),
                 visit(node.arguments.arguments.last)
               )
             else
@@ -789,7 +789,7 @@ module Prism
             if (do_keyword_loc = node.do_keyword_loc)
               token(do_keyword_loc)
             else
-              srange_find(node.collection.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset, ";")
+              srange_semicolon(node.collection.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset)
             end,
             visit(node.statements),
             token(node.end_keyword_loc)
@@ -921,7 +921,7 @@ module Prism
               if (then_keyword_loc = node.then_keyword_loc)
                 token(then_keyword_loc)
               else
-                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.subsequent&.location || node.end_keyword_loc).start_offset, ";")
+                srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.subsequent&.location || node.end_keyword_loc).start_offset)
               end,
               visit(node.statements),
               case node.subsequent
@@ -987,7 +987,7 @@ module Prism
             if (then_loc = node.then_loc)
               token(then_loc)
             else
-              srange_find(node.pattern.location.end_offset, node.statements&.location&.start_offset, ";")
+              srange_semicolon(node.pattern.location.end_offset, node.statements&.location&.start_offset)
             end,
             visit(node.statements)
           )
@@ -1808,7 +1808,7 @@ module Prism
               if (then_keyword_loc = node.then_keyword_loc)
                 token(then_keyword_loc)
               else
-                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.else_clause&.location || node.end_keyword_loc).start_offset, ";")
+                srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.else_clause&.location || node.end_keyword_loc).start_offset)
               end,
               visit(node.else_clause),
               token(node.else_clause&.else_keyword_loc),
@@ -1839,7 +1839,7 @@ module Prism
               if (do_keyword_loc = node.do_keyword_loc)
                 token(do_keyword_loc)
               else
-                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, ";")
+                srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset)
               end,
               visit(node.statements),
               token(node.closing_loc)
@@ -1863,7 +1863,7 @@ module Prism
             if (then_keyword_loc = node.then_keyword_loc)
               token(then_keyword_loc)
             else
-              srange_find(node.conditions.last.location.end_offset, node.statements&.location&.start_offset, ";")
+              srange_semicolon(node.conditions.last.location.end_offset, node.statements&.location&.start_offset)
             end,
             visit(node.statements)
           )
@@ -1883,7 +1883,7 @@ module Prism
               if (do_keyword_loc = node.do_keyword_loc)
                 token(do_keyword_loc)
               else
-                srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, ";")
+                srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset)
               end,
               visit(node.statements),
               token(node.closing_loc)
@@ -2012,16 +2012,16 @@ module Prism
           Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
         end
 
-        # Constructs a new source range by finding the given character between
-        # the given start offset and end offset. If the needle is not found, it
-        # returns nil. Importantly it does not search past newlines or comments.
+        # Constructs a new source range by finding a semicolon between the given
+        # start offset and end offset. If the semicolon is not found, it returns
+        # nil. Importantly it does not search past newlines or comments.
         #
         # Note that end_offset is allowed to be nil, in which case this will
         # search until the end of the string.
-        def srange_find(start_offset, end_offset, character)
-          if (match = source_buffer.source.byteslice(start_offset...end_offset)[/\A\s*#{character}/])
+        def srange_semicolon(start_offset, end_offset)
+          if (match = source_buffer.source.byteslice(start_offset...end_offset)[/\A\s*;/])
             final_offset = start_offset + match.bytesize
-            [character, Range.new(source_buffer, offset_cache[final_offset - character.bytesize], offset_cache[final_offset])]
+            [";", Range.new(source_buffer, offset_cache[final_offset - 1], offset_cache[final_offset])]
           end
         end
 

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism/translation/parser.rb

@@ -84,7 +84,7 @@ module Prism
       end
 
       def version # :nodoc:
-        35
+        41
       end
 
       # The default encoding for Ruby files is UTF-8.
@@ -356,8 +356,10 @@ module Prism
           "3.3.1"
         when 34
           "3.4.0"
-        when 35
-          "3.5.0"
+        when 35, 40
+          "4.0.0"
+        when 41
+          "4.1.0"
         else
           "latest"
         end

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.7.0/lib/prism/translation/parser35.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+# :markup: markdown
+
+module Prism
+  module Translation
+    Parser35 = Parser40 # :nodoc:
+  end
+end

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0/lib/prism/translation/parser35.rb → 4.0.0/gems/prism-1.7.0/lib/prism/translation/parser40.rb}

@@ -3,10 +3,10 @@
 
 module Prism
   module Translation
-    # This class is the entry-point for Ruby 3.5 of `Prism::Translation::Parser`.
-    class Parser35 < Parser
+    # This class is the entry-point for Ruby 4.0 of `Prism::Translation::Parser`.
+    class Parser40 < Parser
       def version # :nodoc:
-        35
+        40
       end
     end
   end

package/plugins/rubyastgen/bundle/ruby/4.0.0/gems/prism-1.7.0/lib/prism/translation/parser41.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+# :markup: markdown
+
+module Prism
+  module Translation
+    # This class is the entry-point for Ruby 4.1 of `Prism::Translation::Parser`.
+    class Parser41 < Parser
+      def version # :nodoc:
+        41
+      end
+    end
+  end
+end

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism/translation/parser_current.rb

@@ -10,8 +10,10 @@ module Prism
       ParserCurrent = Parser33
     when /^3\.4\./
       ParserCurrent = Parser34
-    when /^3\.5\./
-      ParserCurrent = Parser35
+    when /^3\.5\./, /^4\.0\./
+      ParserCurrent = Parser40
+    when /^4\.1\./
+      ParserCurrent = Parser41
     else
       # Keep this in sync with released Ruby.
       parser = Parser34

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism/translation/ripper.rb

@@ -71,7 +71,7 @@ module Prism
       #          [[1, 13], :on_kw,     "end", END      ]]
       #
       def self.lex(src, filename = "-", lineno = 1, raise_errors: false)
-        result = Prism.lex_compat(src, filepath: filename, line: lineno)
+        result = Prism.lex_compat(src, filepath: filename, line: lineno, version: "current")
 
         if result.failure? && raise_errors
           raise SyntaxError, result.errors.first.message
@@ -3295,7 +3295,7 @@ module Prism
 
       # Lazily initialize the parse result.
       def result
-        @result ||= Prism.parse(source, partial_script: true)
+        @result ||= Prism.parse(source, partial_script: true, version: "current")
       end
 
       ##########################################################################

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism/translation/ruby_parser.rb

@@ -2,12 +2,17 @@
 # :markup: markdown
 
 begin
-  require "ruby_parser"
+  require "sexp"
 rescue LoadError
-  warn(%q{Error: Unable to load ruby_parser. Add `gem "ruby_parser"` to your Gemfile.})
+  warn(%q{Error: Unable to load sexp. Add `gem "sexp_processor"` to your Gemfile.})
   exit(1)
 end
 
+class RubyParser # :nodoc:
+  class SyntaxError < RuntimeError # :nodoc:
+  end
+end
+
 module Prism
   module Translation
     # This module is the entry-point for converting a prism syntax tree into the
@@ -415,14 +420,18 @@ module Prism
               visit(node.constant_path)
             end
 
-          if node.body.nil?
-            s(node, :class, name, visit(node.superclass))
-          elsif node.body.is_a?(StatementsNode)
-            compiler = copy_compiler(in_def: false)
-            s(node, :class, name, visit(node.superclass)).concat(node.body.body.map { |child| child.accept(compiler) })
-          else
-            s(node, :class, name, visit(node.superclass), node.body.accept(copy_compiler(in_def: false)))
-          end
+          result =
+            if node.body.nil?
+              s(node, :class, name, visit(node.superclass))
+            elsif node.body.is_a?(StatementsNode)
+              compiler = copy_compiler(in_def: false)
+              s(node, :class, name, visit(node.superclass)).concat(node.body.body.map { |child| child.accept(compiler) })
+            else
+              s(node, :class, name, visit(node.superclass), node.body.accept(copy_compiler(in_def: false)))
+            end
+
+          attach_comments(result, node)
+          result
         end
 
         # ```
@@ -611,7 +620,9 @@ module Prism
               s(node, :defs, visit(node.receiver), name)
             end
 
+          attach_comments(result, node)
           result.line(node.name_loc.start_line)
+
           if node.parameters.nil?
             result << s(node, :args).line(node.name_loc.start_line)
           else
@@ -1270,14 +1281,18 @@ module Prism
               visit(node.constant_path)
             end
 
-          if node.body.nil?
-            s(node, :module, name)
-          elsif node.body.is_a?(StatementsNode)
-            compiler = copy_compiler(in_def: false)
-            s(node, :module, name).concat(node.body.body.map { |child| child.accept(compiler) })
-          else
-            s(node, :module, name, node.body.accept(copy_compiler(in_def: false)))
-          end
+          result =
+            if node.body.nil?
+              s(node, :module, name)
+            elsif node.body.is_a?(StatementsNode)
+              compiler = copy_compiler(in_def: false)
+              s(node, :module, name).concat(node.body.body.map { |child| child.accept(compiler) })
+            else
+              s(node, :module, name, node.body.accept(copy_compiler(in_def: false)))
+            end
+
+          attach_comments(result, node)
+          result
         end
 
         # ```
@@ -1820,6 +1835,17 @@ module Prism
 
         private
 
+        # Attach prism comments to the given sexp.
+        def attach_comments(sexp, node)
+          return unless node.comments
+          return if node.comments.empty?
+
+          extra = node.location.start_line - node.comments.last.location.start_line
+          comments = node.comments.map(&:slice)
+          comments.concat([nil] * [0, extra].max)
+          sexp.comments = comments.join("\n")
+        end
+
         # Create a new compiler with the given options.
         def copy_compiler(in_def: self.in_def, in_pattern: self.in_pattern)
           Compiler.new(file, in_def: in_def, in_pattern: in_pattern)
@@ -1898,6 +1924,14 @@ module Prism
         translate(Prism.parse_file(filepath, partial_script: true), filepath)
       end
 
+      # Parse the give file and translate it into the
+      # seattlerb/ruby_parser gem's Sexp format. This method is
+      # provided for API compatibility to RubyParser and takes an
+      # optional +timeout+ argument.
+      def process(ruby, file = "(string)", timeout = nil)
+        Timeout.timeout(timeout) { parse(ruby, file) }
+      end
+
       class << self
         # Parse the given source and translate it into the seattlerb/ruby_parser
         # gem's Sexp format.
@@ -1922,6 +1956,7 @@ module Prism
           raise ::RubyParser::SyntaxError, "#{filepath}:#{error.location.start_line} :: #{error.message}"
         end
 
+        result.attach_comments!
         result.value.accept(Compiler.new(filepath))
       end
     end

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism/translation.rb

@@ -10,6 +10,8 @@ module Prism
     autoload :Parser33, "prism/translation/parser33"
     autoload :Parser34, "prism/translation/parser34"
     autoload :Parser35, "prism/translation/parser35"
+    autoload :Parser40, "prism/translation/parser40"
+    autoload :Parser41, "prism/translation/parser41"
     autoload :Ripper, "prism/translation/ripper"
     autoload :RubyParser, "prism/translation/ruby_parser"
   end

package/plugins/rubyastgen/bundle/ruby/{3.4.0/gems/prism-1.6.0 → 4.0.0/gems/prism-1.7.0}/lib/prism.rb

@@ -42,13 +42,12 @@ module Prism
     # Initialize a new exception for the given ruby version string.
     def initialize(version)
       message = +"invalid version: Requested to parse as `version: 'current'`; "
-      gem_version =
-        begin
-          Gem::Version.new(version)
-        rescue ArgumentError
+      segments =
+        if version.match?(/\A\d+\.\d+.\d+\z/)
+          version.split(".").map(&:to_i)
         end
 
-      if gem_version && gem_version < Gem::Version.new("3.3.0")
+      if segments && ((segments[0] < 3) || (segments[0] == 3 && segments[1] < 3))
         message << " #{version} is below the minimum supported syntax."
       else
         message << " #{version} is unknown. Please update the `prism` gem."