prism 0.24.0 → 0.29.0

data/lib/prism/translation/parser/lexer.rb

@@ -167,7 +167,7 @@ module Prism
           TILDE: :tTILDE,
           UAMPERSAND: :tAMPER,
           UCOLON_COLON: :tCOLON3,
-          UDOT_DOT: :tDOT2,
+          UDOT_DOT: :tBDOT2,
           UDOT_DOT_DOT: :tBDOT3,
           UMINUS: :tUMINUS,
           UMINUS_NUM: :tUNARY_NUM,
@@ -177,12 +177,23 @@ module Prism
           WORDS_SEP: :tSPACE
         }
 
-        private_constant :TYPES
+        # These constants represent flags in our lex state. We really, really
+        # don't want to be using them and we really, really don't want to be
+        # exposing them as part of our public API. Unfortunately, we don't have
+        # another way of matching the exact tokens that the parser gem expects
+        # without them. We should find another way to do this, but in the
+        # meantime we'll hide them from the documentation and mark them as
+        # private constants.
+        EXPR_BEG = 0x1 # :nodoc:
+        EXPR_LABEL = 0x400 # :nodoc:
+
+        private_constant :TYPES, :EXPR_BEG, :EXPR_LABEL
 
         # The Parser::Source::Buffer that the tokens were lexed from.
         attr_reader :source_buffer
 
-        # An array of prism tokens that we lexed.
+        # An array of tuples that contain prism tokens and their associated lex
+        # state when they were lexed.
         attr_reader :lexed
 
         # A hash that maps offsets in bytes to offsets in characters.
@@ -202,12 +213,16 @@ module Prism
         # Convert the prism tokens into the expected format for the parser gem.
         def to_a
           tokens = []
+
           index = 0
+          length = lexed.length
+
+          heredoc_identifier_stack = []
 
-          while index < lexed.length
-            token, = lexed[index]
+          while index < length
+            token, state = lexed[index]
             index += 1
-            next if token.type == :IGNORED_NEWLINE || token.type == :EOF
+            next if %i[IGNORED_NEWLINE __END__ EOF].include?(token.type)
 
             type = TYPES.fetch(token.type)
             value = token.value
@@ -218,14 +233,18 @@ module Prism
               value.delete_prefix!("?")
             when :tCOMMENT
               if token.type == :EMBDOC_BEGIN
-                until (next_token = lexed[index]) && next_token.type == :EMBDOC_END
+                start_index = index
+
+                while !((next_token = lexed[index][0]) && next_token.type == :EMBDOC_END) && (index < length - 1)
                   value += next_token.value
                   index += 1
                 end
 
-                value += next_token.value
-                location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[lexed[index].location.end_offset])
-                index += 1
+                if start_index != index
+                  value += next_token.value
+                  location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[lexed[index][0].location.end_offset])
+                  index += 1
+                end
               else
                 value.chomp!
                 location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[token.location.end_offset - 1])
@@ -233,7 +252,7 @@ module Prism
             when :tNL
               value = nil
             when :tFLOAT
-              value = Float(value)
+              value = parse_float(value)
             when :tIMAGINARY
               value = parse_complex(value)
             when :tINTEGER
@@ -242,13 +261,15 @@ module Prism
                 location = Range.new(source_buffer, offset_cache[token.location.start_offset + 1], offset_cache[token.location.end_offset])
               end
 
-              value = Integer(value)
+              value = parse_integer(value)
             when :tLABEL
               value.chomp!(":")
             when :tLABEL_END
               value.chomp!(":")
+            when :tLCURLY
+              type = :tLBRACE if state == EXPR_BEG | EXPR_LABEL
             when :tNTH_REF
-              value = Integer(value.delete_prefix("$"))
+              value = parse_integer(value.delete_prefix("$"))
             when :tOP_ASGN
               value.chomp!("=")
             when :tRATIONAL
@@ -256,31 +277,69 @@ module Prism
             when :tSPACE
               value = nil
             when :tSTRING_BEG
-              if ["\"", "'"].include?(value) && (next_token = lexed[index]) && next_token.type == :STRING_END
+              if token.type == :HEREDOC_START
+                heredoc_identifier_stack.push(value.match(/<<[-~]?["'`]?(?<heredoc_identifier>.*?)["'`]?\z/)[:heredoc_identifier])
+              end
+              if ["\"", "'"].include?(value) && (next_token = lexed[index][0]) && next_token.type == :STRING_END
                 next_location = token.location.join(next_token.location)
                 type = :tSTRING
                 value = ""
                 location = Range.new(source_buffer, offset_cache[next_location.start_offset], offset_cache[next_location.end_offset])
                 index += 1
-              elsif ["\"", "'"].include?(value) && (next_token = lexed[index]) && next_token.type == :STRING_CONTENT && (next_next_token = lexed[index + 1]) && next_next_token.type == :STRING_END
+              elsif ["\"", "'"].include?(value) && (next_token = lexed[index][0]) && next_token.type == :STRING_CONTENT && next_token.value.lines.count <= 1 && (next_next_token = lexed[index + 1][0]) && next_next_token.type == :STRING_END
                 next_location = token.location.join(next_next_token.location)
                 type = :tSTRING
-                value = next_token.value
+                value = next_token.value.gsub("\\\\", "\\")
                 location = Range.new(source_buffer, offset_cache[next_location.start_offset], offset_cache[next_location.end_offset])
                 index += 2
               elsif value.start_with?("<<")
                 quote = value[2] == "-" || value[2] == "~" ? value[3] : value[2]
-                value = "<<#{quote == "'" || quote == "\"" ? quote : "\""}"
+                if quote == "`"
+                  type = :tXSTRING_BEG
+                  value = "<<`"
+                else
+                  value = "<<#{quote == "'" || quote == "\"" ? quote : "\""}"
+                end
+              end
+            when :tSTRING_CONTENT
+              unless (lines = token.value.lines).one?
+                start_offset = offset_cache[token.location.start_offset]
+                lines.map do |line|
+                  newline = line.end_with?("\r\n") ? "\r\n" : "\n"
+                  chomped_line = line.chomp
+                  if match = chomped_line.match(/(?<backslashes>\\+)\z/)
+                    adjustment = match[:backslashes].size / 2
+                    adjusted_line = chomped_line.delete_suffix("\\" * adjustment)
+                    if match[:backslashes].size.odd?
+                      adjusted_line.delete_suffix!("\\")
+                      adjustment += 2
+                    else
+                      adjusted_line << newline
+                    end
+                  else
+                    adjusted_line = line
+                    adjustment = 0
+                  end
+
+                  end_offset = start_offset + adjusted_line.length + adjustment
+                  tokens << [:tSTRING_CONTENT, [adjusted_line, Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])]]
+                  start_offset = end_offset
+                end
+                next
               end
             when :tSTRING_DVAR
               value = nil
             when :tSTRING_END
-              if token.type == :REGEXP_END
+              if token.type == :HEREDOC_END && value.end_with?("\n")
+                newline_length = value.end_with?("\r\n") ? 2 : 1
+                value = heredoc_identifier_stack.pop
+                location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[token.location.end_offset - newline_length])
+              elsif token.type == :REGEXP_END
                 value = value[0]
                 location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[token.location.start_offset + 1])
               end
             when :tSYMBEG
-              if (next_token = lexed[index]) && next_token.type != :STRING_CONTENT && next_token.type != :EMBEXPR_BEGIN && next_token.type != :EMBVAR
+              if (next_token = lexed[index][0]) && next_token.type != :STRING_CONTENT && next_token.type != :EMBEXPR_BEGIN && next_token.type != :EMBVAR
                 next_location = token.location.join(next_token.location)
                 type = :tSYMBOL
                 value = next_token.value
@@ -289,9 +348,13 @@ module Prism
                 index += 1
               end
             when :tFID
-              if tokens[-1][0] == :kDEF
+              if !tokens.empty? && tokens.dig(-1, 0) == :kDEF
                 type = :tIDENTIFIER
               end
+            when :tXSTRING_BEG
+              if (next_token = lexed[index][0]) && next_token.type != :STRING_CONTENT && next_token.type != :STRING_END
+                type = :tBACK_REF2
+              end
             end
 
             tokens << [type, [value, location]]
@@ -306,6 +369,20 @@ module Prism
 
         private
 
+        # Parse an integer from the string representation.
+        def parse_integer(value)
+          Integer(value)
+        rescue ArgumentError
+          0
+        end
+
+        # Parse a float from the string representation.
+        def parse_float(value)
+          Float(value)
+        rescue ArgumentError
+          0.0
+        end
+
         # Parse a complex from the string representation.
         def parse_complex(value)
           value.chomp!("i")
@@ -313,10 +390,12 @@ module Prism
           if value.end_with?("r")
             Complex(0, parse_rational(value))
           elsif value.start_with?(/0[BbOoDdXx]/)
-            Complex(0, Integer(value))
+            Complex(0, parse_integer(value))
           else
             Complex(0, value)
           end
+        rescue ArgumentError
+          0i
         end
 
         # Parse a rational from the string representation.
@@ -324,10 +403,12 @@ module Prism
           value.chomp!("r")
 
           if value.start_with?(/0[BbOoDdXx]/)
-            Rational(Integer(value))
+            Rational(parse_integer(value))
           else
             Rational(value)
           end
+        rescue ArgumentError
+          0r
         end
       end
     end

data/lib/prism/translation/parser/rubocop.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
+# typed: ignore
+
+warn "WARN: Prism is directly supported since RuboCop 1.62. The `prism/translation/parser/rubocop` file is deprecated."
 
 require "parser"
 require "rubocop"
 
-require "prism"
-require "prism/translation/parser"
+require_relative "../../prism"
+require_relative "../parser"
 
 module Prism
   module Translation
@@ -20,17 +23,42 @@ module Prism
 
       # This module gets prepended into RuboCop::AST::ProcessedSource.
       module ProcessedSource
-        # Redefine parser_class so that we can inject the prism parser into the
-        # list of known parsers.
-        def parser_class(ruby_version)
-          if ruby_version == Prism::Translation::Parser::VERSION_3_3
-            require "prism/translation/parser33"
-            Prism::Translation::Parser33
-          elsif ruby_version == Prism::Translation::Parser::VERSION_3_4
-            require "prism/translation/parser34"
-            Prism::Translation::Parser34
-          else
-            super
+        # This condition is compatible with rubocop-ast versions up to 1.30.0.
+        if RuboCop::AST::ProcessedSource.instance_method(:parser_class).arity == 1
+          # Redefine parser_class so that we can inject the prism parser into the
+          # list of known parsers.
+          def parser_class(ruby_version)
+            if ruby_version == Prism::Translation::Parser::VERSION_3_3
+              warn "WARN: Setting `TargetRubyVersion: 80_82_73_83_77.33` is deprecated. " \
+                   "Set to `ParserEngine: parser_prism` and `TargetRubyVersion: 3.3` instead."
+              require_relative "../parser33"
+              Prism::Translation::Parser33
+            elsif ruby_version == Prism::Translation::Parser::VERSION_3_4
+              warn "WARN: Setting `TargetRubyVersion: 80_82_73_83_77.34` is deprecated. " \
+                   "Set to `ParserEngine: parser_prism` and `TargetRubyVersion: 3.4` instead."
+              require_relative "../parser34"
+              Prism::Translation::Parser34
+            else
+              super
+            end
+          end
+        else
+          # Redefine parser_class so that we can inject the prism parser into the
+          # list of known parsers.
+          def parser_class(ruby_version, _parser_engine)
+            if ruby_version == Prism::Translation::Parser::VERSION_3_3
+              warn "WARN: Setting `TargetRubyVersion: 80_82_73_83_77.33` is deprecated. " \
+                   "Set to `ParserEngine: parser_prism` and `TargetRubyVersion: 3.3` instead."
+              require_relative "../parser33"
+              Prism::Translation::Parser33
+            elsif ruby_version == Prism::Translation::Parser::VERSION_3_4
+              warn "WARN: Setting `TargetRubyVersion: 80_82_73_83_77.34` is deprecated. " \
+                   "Set to `ParserEngine: parser_prism` and `TargetRubyVersion: 3.4` instead."
+              require_relative "../parser34"
+              Prism::Translation::Parser34
+            else
+              super
+            end
           end
         end
       end

data/lib/prism/translation/parser.rb

@@ -9,17 +9,20 @@ module Prism
     # the parser gem, and overrides the parse* methods to parse with prism and
     # then translate.
     class Parser < ::Parser::Base
+      Diagnostic = ::Parser::Diagnostic # :nodoc:
+      private_constant :Diagnostic
+
       # The parser gem has a list of diagnostics with a hard-coded set of error
       # messages. We create our own diagnostic class in order to set our own
       # error messages.
-      class Diagnostic < ::Parser::Diagnostic
-        # The message generated by prism.
+      class PrismDiagnostic < Diagnostic
+        # This is the cached message coming from prism.
         attr_reader :message
 
         # Initialize a new diagnostic with the given message and location.
-        def initialize(message, location)
+        def initialize(message, level, reason, location)
           @message = message
-          super(:error, :prism_error, {}, location, [])
+          super(level, reason, {}, location, [])
         end
       end
 
@@ -43,7 +46,7 @@ module Prism
         source = source_buffer.source
 
         offset_cache = build_offset_cache(source)
-        result = unwrap(Prism.parse(source, filepath: source_buffer.name, version: convert_for_prism(version)), offset_cache)
+        result = unwrap(Prism.parse(source, filepath: source_buffer.name, version: convert_for_prism(version), scopes: [[]]), offset_cache)
 
         build_ast(result.value, offset_cache)
       ensure
@@ -56,7 +59,7 @@ module Prism
         source = source_buffer.source
 
         offset_cache = build_offset_cache(source)
-        result = unwrap(Prism.parse(source, filepath: source_buffer.name, version: convert_for_prism(version)), offset_cache)
+        result = unwrap(Prism.parse(source, filepath: source_buffer.name, version: convert_for_prism(version), scopes: [[]]), offset_cache)
 
         [
           build_ast(result.value, offset_cache),
@@ -75,7 +78,7 @@ module Prism
         offset_cache = build_offset_cache(source)
         result =
           begin
-            unwrap(Prism.parse_lex(source, filepath: source_buffer.name, version: convert_for_prism(version)), offset_cache)
+            unwrap(Prism.parse_lex(source, filepath: source_buffer.name, version: convert_for_prism(version), scopes: [[]]), offset_cache)
           rescue ::Parser::SyntaxError
             raise if !recover
           end
@@ -106,14 +109,123 @@ module Prism
         true
       end
 
+      # This is a hook to allow consumers to disable some warnings if they don't
+      # want them to block creating the syntax tree.
+      def valid_warning?(warning)
+        true
+      end
+
+      # Build a diagnostic from the given prism parse error.
+      def error_diagnostic(error, offset_cache)
+        location = error.location
+        diagnostic_location = build_range(location, offset_cache)
+
+        case error.type
+        when :argument_block_multi
+          Diagnostic.new(:error, :block_and_blockarg, {}, diagnostic_location, [])
+        when :argument_formal_constant
+          Diagnostic.new(:error, :argument_const, {}, diagnostic_location, [])
+        when :argument_formal_class
+          Diagnostic.new(:error, :argument_cvar, {}, diagnostic_location, [])
+        when :argument_formal_global
+          Diagnostic.new(:error, :argument_gvar, {}, diagnostic_location, [])
+        when :argument_formal_ivar
+          Diagnostic.new(:error, :argument_ivar, {}, diagnostic_location, [])
+        when :argument_no_forwarding_amp
+          Diagnostic.new(:error, :no_anonymous_blockarg, {}, diagnostic_location, [])
+        when :argument_no_forwarding_star
+          Diagnostic.new(:error, :no_anonymous_restarg, {}, diagnostic_location, [])
+        when :argument_no_forwarding_star_star
+          Diagnostic.new(:error, :no_anonymous_kwrestarg, {}, diagnostic_location, [])
+        when :begin_lonely_else
+          location = location.copy(length: 4)
+          diagnostic_location = build_range(location, offset_cache)
+          Diagnostic.new(:error, :useless_else, {}, diagnostic_location, [])
+        when :class_name, :module_name
+          Diagnostic.new(:error, :module_name_const, {}, diagnostic_location, [])
+        when :class_in_method
+          Diagnostic.new(:error, :class_in_def, {}, diagnostic_location, [])
+        when :def_endless_setter
+          Diagnostic.new(:error, :endless_setter, {}, diagnostic_location, [])
+        when :embdoc_term
+          Diagnostic.new(:error, :embedded_document, {}, diagnostic_location, [])
+        when :incomplete_variable_class, :incomplete_variable_class_3_3
+          location = location.copy(length: location.length + 1)
+          diagnostic_location = build_range(location, offset_cache)
+
+          Diagnostic.new(:error, :cvar_name, { name: location.slice }, diagnostic_location, [])
+        when :incomplete_variable_instance, :incomplete_variable_instance_3_3
+          location = location.copy(length: location.length + 1)
+          diagnostic_location = build_range(location, offset_cache)
+
+          Diagnostic.new(:error, :ivar_name, { name: location.slice }, diagnostic_location, [])
+        when :invalid_variable_global, :invalid_variable_global_3_3
+          Diagnostic.new(:error, :gvar_name, { name: location.slice }, diagnostic_location, [])
+        when :module_in_method
+          Diagnostic.new(:error, :module_in_def, {}, diagnostic_location, [])
+        when :numbered_parameter_ordinary
+          Diagnostic.new(:error, :ordinary_param_defined, {}, diagnostic_location, [])
+        when :numbered_parameter_outer_scope
+          Diagnostic.new(:error, :numparam_used_in_outer_scope, {}, diagnostic_location, [])
+        when :parameter_circular
+          Diagnostic.new(:error, :circular_argument_reference, { var_name: location.slice }, diagnostic_location, [])
+        when :parameter_name_repeat
+          Diagnostic.new(:error, :duplicate_argument, {}, diagnostic_location, [])
+        when :parameter_numbered_reserved
+          Diagnostic.new(:error, :reserved_for_numparam, { name: location.slice }, diagnostic_location, [])
+        when :regexp_unknown_options
+          Diagnostic.new(:error, :regexp_options, { options: location.slice[1..] }, diagnostic_location, [])
+        when :singleton_for_literals
+          Diagnostic.new(:error, :singleton_literal, {}, diagnostic_location, [])
+        when :string_literal_eof
+          Diagnostic.new(:error, :string_eof, {}, diagnostic_location, [])
+        when :unexpected_token_ignore
+          Diagnostic.new(:error, :unexpected_token, { token: location.slice }, diagnostic_location, [])
+        when :write_target_in_method
+          Diagnostic.new(:error, :dynamic_const, {}, diagnostic_location, [])
+        else
+          PrismDiagnostic.new(error.message, :error, error.type, diagnostic_location)
+        end
+      end
+
+      # Build a diagnostic from the given prism parse warning.
+      def warning_diagnostic(warning, offset_cache)
+        diagnostic_location = build_range(warning.location, offset_cache)
+
+        case warning.type
+        when :ambiguous_first_argument_plus
+          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "+" }, diagnostic_location, [])
+        when :ambiguous_first_argument_minus
+          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "-" }, diagnostic_location, [])
+        when :ambiguous_prefix_ampersand
+          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "&" }, diagnostic_location, [])
+        when :ambiguous_prefix_star
+          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "*" }, diagnostic_location, [])
+        when :ambiguous_prefix_star_star
+          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "**" }, diagnostic_location, [])
+        when :ambiguous_slash
+          Diagnostic.new(:warning, :ambiguous_regexp, {}, diagnostic_location, [])
+        when :dot_dot_dot_eol
+          Diagnostic.new(:warning, :triple_dot_at_eol, {}, diagnostic_location, [])
+        when :duplicated_hash_key
+          # skip, parser does this on its own
+        else
+          PrismDiagnostic.new(warning.message, :warning, warning.type, diagnostic_location)
+        end
+      end
+
       # If there was a error generated during the parse, then raise an
       # appropriate syntax error. Otherwise return the result.
       def unwrap(result, offset_cache)
         result.errors.each do |error|
           next unless valid_error?(error)
+          diagnostics.process(error_diagnostic(error, offset_cache))
+        end
 
-          location = build_range(error.location, offset_cache)
-          diagnostics.process(Diagnostic.new(error.message, location))
+        result.warnings.each do |warning|
+          next unless valid_warning?(warning)
+          diagnostic = warning_diagnostic(warning, offset_cache)
+          diagnostics.process(diagnostic) if diagnostic
         end
 
         result
@@ -156,7 +268,7 @@ module Prism
 
       # Build the parser gem tokens from the prism tokens.
       def build_tokens(tokens, offset_cache)
-        Lexer.new(source_buffer, tokens.map(&:first), offset_cache).to_a
+        Lexer.new(source_buffer, tokens, offset_cache).to_a
       end
 
       # Build a range from a prism location.
@@ -172,7 +284,7 @@ module Prism
       def convert_for_prism(version)
         case version
         when 33
-          "3.3.0"
+          "3.3.1"
         when 34
           "3.4.0"
         else

data/lib/prism/translation/parser33.rb

@@ -1,4 +1,4 @@
-require_relative "parser"
+# frozen_string_literal: true
 
 module Prism
   module Translation

data/lib/prism/translation/parser34.rb

@@ -1,4 +1,4 @@
-require_relative "parser"
+# frozen_string_literal: true
 
 module Prism
   module Translation

data/lib/prism/translation/ripper/sexp.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "../ripper"
+
+module Prism
+  module Translation
+    class Ripper
+      # This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
+      # returns the arrays of [type, *children].
+      class SexpBuilder < Ripper
+        # :stopdoc:
+
+        attr_reader :error
+
+        private
+
+        def dedent_element(e, width)
+          if (n = dedent_string(e[1], width)) > 0
+            e[2][1] += n
+          end
+          e
+        end
+
+        def on_heredoc_dedent(val, width)
+          sub = proc do |cont|
+            cont.map! do |e|
+              if Array === e
+                case e[0]
+                when :@tstring_content
+                  e = dedent_element(e, width)
+                when /_add\z/
+                  e[1] = sub[e[1]]
+                end
+              elsif String === e
+                dedent_string(e, width)
+              end
+              e
+            end
+          end
+          sub[val]
+          val
+        end
+
+        events = private_instance_methods(false).grep(/\Aon_/) {$'.to_sym}
+        (PARSER_EVENTS - events).each do |event|
+          module_eval(<<-End, __FILE__, __LINE__ + 1)
+            def on_#{event}(*args)
+              args.unshift :#{event}
+            end
+          End
+        end
+
+        SCANNER_EVENTS.each do |event|
+          module_eval(<<-End, __FILE__, __LINE__ + 1)
+            def on_#{event}(tok)
+              [:@#{event}, tok, [lineno(), column()]]
+            end
+          End
+        end
+
+        def on_error(mesg)
+          @error = mesg
+        end
+        remove_method :on_parse_error
+        alias on_parse_error on_error
+        alias compile_error on_error
+
+        # :startdoc:
+      end
+
+      # This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
+      # returns the same values as ::Ripper::SexpBuilder except with a couple of
+      # niceties that flatten linked lists into arrays.
+      class SexpBuilderPP < SexpBuilder
+        # :stopdoc:
+
+        private
+
+        def on_heredoc_dedent(val, width)
+          val.map! do |e|
+            next e if Symbol === e and /_content\z/ =~ e
+            if Array === e and e[0] == :@tstring_content
+              e = dedent_element(e, width)
+            elsif String === e
+              dedent_string(e, width)
+            end
+            e
+          end
+          val
+        end
+
+        def _dispatch_event_new
+          []
+        end
+
+        def _dispatch_event_push(list, item)
+          list.push item
+          list
+        end
+
+        def on_mlhs_paren(list)
+          [:mlhs, *list]
+        end
+
+        def on_mlhs_add_star(list, star)
+          list.push([:rest_param, star])
+        end
+
+        def on_mlhs_add_post(list, post)
+          list.concat(post)
+        end
+
+        PARSER_EVENT_TABLE.each do |event, arity|
+          if /_new\z/ =~ event and arity == 0
+            alias_method "on_#{event}", :_dispatch_event_new
+          elsif /_add\z/ =~ event
+            alias_method "on_#{event}", :_dispatch_event_push
+          end
+        end
+
+        # :startdoc:
+      end
+    end
+  end
+end

data/lib/prism/translation/ripper/shim.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# This writes the prism ripper translation into the Ripper constant so that
+# users can transparently use Ripper without any changes.
+Ripper = Prism::Translation::Ripper