prism 1.4.0 → 1.6.0

data/lib/prism/node_ext.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
+# :markup: markdown
 
+#--
 # Here we are reopening the prism module to provide methods on nodes that aren't
 # templated and are meant as convenience methods.
+#++
 module Prism
   class Node
     def deprecated(*replacements) # :nodoc:
@@ -9,7 +12,7 @@ module Prism
       location = location[0].label if location
       suggest = replacements.map { |replacement| "#{self.class}##{replacement}" }
 
-      warn(<<~MSG, category: :deprecated)
+      warn(<<~MSG, uplevel: 1, category: :deprecated)
         [deprecation]: #{self.class}##{location} is deprecated and will be \
         removed in the next major version. Use #{suggest.join("/")} instead.
         #{(caller(1, 3) || []).join("\n")}

data/lib/prism/pack.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+# :markup: markdown
 # typed: ignore
 
+#
 module Prism
   # A parser for the pack template language.
   module Pack

data/lib/prism/parse_result/comments.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   class ParseResult < Result

data/lib/prism/parse_result/errors.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 require "stringio"
 

data/lib/prism/parse_result/newlines.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   class ParseResult < Result

data/lib/prism/parse_result.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   # This represents a source of Ruby code that has been parsed. It is used in

data/lib/prism/pattern.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   # A pattern is an object that wraps a Ruby pattern matching expression. The

data/lib/prism/polyfill/scan_byte.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+# Polyfill for StringScanner#scan_byte, which didn't exist until Ruby 3.4.
+if !(StringScanner.instance_methods.include?(:scan_byte))
+  StringScanner.include(
+    Module.new {
+      def scan_byte # :nodoc:
+        get_byte&.b&.ord
+      end
+    }
+  )
+end

data/lib/prism/polyfill/warn.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Polyfill for Kernel#warn with the category parameter. Not all Ruby engines
+# have Method#parameters implemented, so we check the arity instead if
+# necessary.
+if (method = Kernel.instance_method(:warn)).respond_to?(:parameters) ? method.parameters.none? { |_, name| name == :category } : (method.arity == -1)
+  Kernel.prepend(
+    Module.new {
+      def warn(*msgs, uplevel: nil, category: nil) # :nodoc:
+        case uplevel
+        when nil
+          super(*msgs)
+        when Integer
+          super(*msgs, uplevel: uplevel + 1)
+        else
+          super(*msgs, uplevel: uplevel.to_int + 1)
+        end
+      end
+    }
+  )
+
+  Object.prepend(
+    Module.new {
+      def warn(*msgs, uplevel: nil, category: nil) # :nodoc:
+        case uplevel
+        when nil
+          super(*msgs)
+        when Integer
+          super(*msgs, uplevel: uplevel + 1)
+        else
+          super(*msgs, uplevel: uplevel.to_int + 1)
+        end
+      end
+    }
+  )
+end

data/lib/prism/reflection.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 =begin
+--
 This file is generated by the templates/template.rb script and should not be
 modified manually. See templates/lib/prism/reflection.rb.erb
 if you are looking to modify the template
+++
 =end
 
 module Prism

data/lib/prism/relocation.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   # Prism parses deterministically for the same input. This provides a nice

data/lib/prism/serialize.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 =begin
+--
 This file is generated by the templates/template.rb script and should not be
 modified manually. See templates/lib/prism/serialize.rb.erb
 if you are looking to modify the template
+++
 =end
 
 require "stringio"
@@ -18,7 +21,7 @@ module Prism
 
     # The minor version of prism that we are expecting to find in the serialized
     # strings.
-    MINOR_VERSION = 4
+    MINOR_VERSION = 6
 
     # The patch version of prism that we are expecting to find in the serialized
     # strings.
@@ -394,6 +397,7 @@ module Prism
         :conditional_while_predicate,
         :constant_path_colon_colon_constant,
         :def_endless,
+        :def_endless_parameters,
         :def_endless_setter,
         :def_name,
         :def_params_term,
@@ -435,6 +439,8 @@ module Prism
         :expect_for_delimiter,
         :expect_ident_req_parameter,
         :expect_in_delimiter,
+        :expect_lparen_after_not_lparen,
+        :expect_lparen_after_not_other,
         :expect_lparen_req_parameter,
         :expect_message,
         :expect_rbracket,
@@ -2219,8 +2225,21 @@ module Prism
     TOKEN_TYPES = [
       nil,
       :EOF,
-      :MISSING,
-      :NOT_PROVIDED,
+      :BRACE_RIGHT,
+      :COMMA,
+      :EMBEXPR_END,
+      :KEYWORD_DO,
+      :KEYWORD_ELSE,
+      :KEYWORD_ELSIF,
+      :KEYWORD_END,
+      :KEYWORD_ENSURE,
+      :KEYWORD_IN,
+      :KEYWORD_RESCUE,
+      :KEYWORD_THEN,
+      :KEYWORD_WHEN,
+      :NEWLINE,
+      :PARENTHESIS_RIGHT,
+      :SEMICOLON,
       :AMPERSAND,
       :AMPERSAND_AMPERSAND,
       :AMPERSAND_AMPERSAND_EQUAL,
@@ -2232,7 +2251,6 @@ module Prism
       :BANG_EQUAL,
       :BANG_TILDE,
       :BRACE_LEFT,
-      :BRACE_RIGHT,
       :BRACKET_LEFT,
       :BRACKET_LEFT_ARRAY,
       :BRACKET_LEFT_RIGHT,
@@ -2244,7 +2262,6 @@ module Prism
       :CLASS_VARIABLE,
       :COLON,
       :COLON_COLON,
-      :COMMA,
       :COMMENT,
       :CONSTANT,
       :DOT,
@@ -2254,7 +2271,6 @@ module Prism
       :EMBDOC_END,
       :EMBDOC_LINE,
       :EMBEXPR_BEGIN,
-      :EMBEXPR_END,
       :EMBVAR,
       :EQUAL,
       :EQUAL_EQUAL,
@@ -2288,38 +2304,29 @@ module Prism
       :KEYWORD_CLASS,
       :KEYWORD_DEF,
       :KEYWORD_DEFINED,
-      :KEYWORD_DO,
       :KEYWORD_DO_LOOP,
-      :KEYWORD_ELSE,
-      :KEYWORD_ELSIF,
-      :KEYWORD_END,
       :KEYWORD_END_UPCASE,
-      :KEYWORD_ENSURE,
       :KEYWORD_FALSE,
       :KEYWORD_FOR,
       :KEYWORD_IF,
       :KEYWORD_IF_MODIFIER,
-      :KEYWORD_IN,
       :KEYWORD_MODULE,
       :KEYWORD_NEXT,
       :KEYWORD_NIL,
       :KEYWORD_NOT,
       :KEYWORD_OR,
       :KEYWORD_REDO,
-      :KEYWORD_RESCUE,
       :KEYWORD_RESCUE_MODIFIER,
       :KEYWORD_RETRY,
       :KEYWORD_RETURN,
       :KEYWORD_SELF,
       :KEYWORD_SUPER,
-      :KEYWORD_THEN,
       :KEYWORD_TRUE,
       :KEYWORD_UNDEF,
       :KEYWORD_UNLESS,
       :KEYWORD_UNLESS_MODIFIER,
       :KEYWORD_UNTIL,
       :KEYWORD_UNTIL_MODIFIER,
-      :KEYWORD_WHEN,
       :KEYWORD_WHILE,
       :KEYWORD_WHILE_MODIFIER,
       :KEYWORD_YIELD,
@@ -2338,11 +2345,9 @@ module Prism
       :MINUS,
       :MINUS_EQUAL,
       :MINUS_GREATER,
-      :NEWLINE,
       :NUMBERED_REFERENCE,
       :PARENTHESIS_LEFT,
       :PARENTHESIS_LEFT_PARENTHESES,
-      :PARENTHESIS_RIGHT,
       :PERCENT,
       :PERCENT_EQUAL,
       :PERCENT_LOWER_I,
@@ -2359,7 +2364,6 @@ module Prism
       :QUESTION_MARK,
       :REGEXP_BEGIN,
       :REGEXP_END,
-      :SEMICOLON,
       :SLASH,
       :SLASH_EQUAL,
       :STAR,
@@ -2382,7 +2386,9 @@ module Prism
       :USTAR_STAR,
       :WORDS_SEP,
       :__END__,
-    ]
+      :MISSING,
+      :NOT_PROVIDED,
+    ].freeze
 
     private_constant :MAJOR_VERSION, :MINOR_VERSION, :PATCH_VERSION
     private_constant :ConstantPool, :FastStringIO, :Loader, :TOKEN_TYPES

data/lib/prism/string_query.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   # Query methods that allow categorizing strings based on their context for

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   module Translation

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   module Translation
@@ -133,8 +134,8 @@ module Prism
         def visit_assoc_node(node)
           key = node.key
 
-          if in_pattern
-            if node.value.is_a?(ImplicitNode)
+          if  node.value.is_a?(ImplicitNode)
+            if in_pattern
               if key.is_a?(SymbolNode)
                 if key.opening.nil?
                   builder.match_hash_var([key.unescaped, srange(key.location)])
@@ -144,23 +145,19 @@ module Prism
               else
                 builder.match_hash_var_from_str(token(key.opening_loc), visit_all(key.parts), token(key.closing_loc))
               end
-            elsif key.opening.nil?
-              builder.pair_keyword([key.unescaped, srange(key.location)], visit(node.value))
             else
-              builder.pair_quoted(token(key.opening_loc), [builder.string_internal([key.unescaped, srange(key.value_loc)])], token(key.closing_loc), visit(node.value))
-            end
-          elsif node.value.is_a?(ImplicitNode)
-            value = node.value.value
+              value = node.value.value
 
-            implicit_value = if value.is_a?(CallNode)
-              builder.call_method(nil, nil, [value.name, srange(value.message_loc)])
-            elsif value.is_a?(ConstantReadNode)
-              builder.const([value.name, srange(key.value_loc)])
-            else
-              builder.ident([value.name, srange(key.value_loc)]).updated(:lvar)
-            end
+              implicit_value = if value.is_a?(CallNode)
+                builder.call_method(nil, nil, [value.name, srange(value.message_loc)])
+              elsif value.is_a?(ConstantReadNode)
+                builder.const([value.name, srange(key.value_loc)])
+              else
+                builder.ident([value.name, srange(key.value_loc)]).updated(:lvar)
+              end
 
-            builder.pair_keyword([key.unescaped, srange(key)], implicit_value)
+              builder.pair_keyword([key.unescaped, srange(key)], implicit_value)
+            end
           elsif node.operator_loc
             builder.pair(visit(key), token(node.operator_loc), visit(node.value))
           elsif key.is_a?(SymbolNode) && key.opening_loc.nil?
@@ -696,13 +693,37 @@ module Prism
         # defined?(a)
         # ^^^^^^^^^^^
         def visit_defined_node(node)
-          builder.keyword_cmd(
-            :defined?,
-            token(node.keyword_loc),
-            token(node.lparen_loc),
-            [visit(node.value)],
-            token(node.rparen_loc)
-          )
+          # Very weird circumstances here where something like:
+          #
+          #     defined?
+          #     (1)
+          #
+          # gets parsed in Ruby as having only the `1` expression but in parser
+          # it gets parsed as having a begin. In this case we need to synthesize
+          # that begin to match parser's behavior.
+          if node.lparen_loc && node.keyword_loc.join(node.lparen_loc).slice.include?("\n")
+            builder.keyword_cmd(
+              :defined?,
+              token(node.keyword_loc),
+              nil,
+              [
+                builder.begin(
+                  token(node.lparen_loc),
+                  visit(node.value),
+                  token(node.rparen_loc)
+                )
+              ],
+              nil
+            )
+          else
+            builder.keyword_cmd(
+              :defined?,
+              token(node.keyword_loc),
+              token(node.lparen_loc),
+              [visit(node.value)],
+              token(node.rparen_loc)
+            )
+          end
         end
 
         # if foo then bar else baz end
@@ -1032,7 +1053,7 @@ module Prism
           builder.index_asgn(
             visit(node.receiver),
             token(node.opening_loc),
-            visit_all(node.arguments.arguments),
+            visit_all(node.arguments&.arguments || []),
             token(node.closing_loc),
           )
         end
@@ -1461,7 +1482,8 @@ module Prism
         # foo => ^(bar)
         #        ^^^^^^
         def visit_pinned_expression_node(node)
-          expression = builder.begin(token(node.lparen_loc), visit(node.expression), token(node.rparen_loc))
+          parts = node.expression.accept(copy_compiler(in_pattern: false)) # Don't treat * and similar as match_rest
+          expression = builder.begin(token(node.lparen_loc), parts, token(node.rparen_loc))
           builder.pin(token(node.operator_loc), expression)
         end
 

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

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 require "strscan"
 require_relative "../../polyfill/append_as_bytes"
+require_relative "../../polyfill/scan_byte"
 
 module Prism
   module Translation
@@ -200,8 +202,8 @@ module Prism
         # The `PARENTHESIS_LEFT` token in Prism is classified as either `tLPAREN` or `tLPAREN2` in the Parser gem.
         # The following token types are listed as those classified as `tLPAREN`.
         LPAREN_CONVERSION_TOKEN_TYPES = Set.new([
-          :kBREAK, :kCASE, :tDIVIDE, :kFOR, :kIF, :kNEXT, :kRETURN, :kUNTIL, :kWHILE, :tAMPER, :tANDOP, :tBANG, :tCOMMA, :tDOT2, :tDOT3,
-          :tEQL, :tLPAREN, :tLPAREN2, :tLPAREN_ARG, :tLSHFT, :tNL, :tOP_ASGN, :tOROP, :tPIPE, :tSEMI, :tSTRING_DBEG, :tUMINUS, :tUPLUS
+          :kBREAK, :tCARET, :kCASE, :tDIVIDE, :kFOR, :kIF, :kNEXT, :kRETURN, :kUNTIL, :kWHILE, :tAMPER, :tANDOP, :tBANG, :tCOMMA, :tDOT2, :tDOT3,
+          :tEQL, :tLPAREN, :tLPAREN2, :tLPAREN_ARG, :tLSHFT, :tNL, :tOP_ASGN, :tOROP, :tPIPE, :tSEMI, :tSTRING_DBEG, :tUMINUS, :tUPLUS, :tLCURLY
         ])
 
         # Types of tokens that are allowed to continue a method call with comments in-between.
@@ -275,20 +277,20 @@ module Prism
             when :tCOMMENT
               if token.type == :EMBDOC_BEGIN
 
-                while !((next_token = lexed[index][0]) && next_token.type == :EMBDOC_END) && (index < length - 1)
+                while !((next_token = lexed[index]&.first) && next_token.type == :EMBDOC_END) && (index < length - 1)
                   value += next_token.value
                   index += 1
                 end
 
                 value += next_token.value
-                location = range(token.location.start_offset, lexed[index][0].location.end_offset)
+                location = range(token.location.start_offset, next_token.location.end_offset)
                 index += 1
               else
                 is_at_eol = value.chomp!.nil?
                 location = range(token.location.start_offset, token.location.end_offset + (is_at_eol ? 0 : -1))
 
-                prev_token = lexed[index - 2][0] if index - 2 >= 0
-                next_token = lexed[index][0]
+                prev_token, _ = lexed[index - 2] if index - 2 >= 0
+                next_token, _ = lexed[index]
 
                 is_inline_comment = prev_token&.location&.start_line == token.location.start_line
                 if is_inline_comment && !is_at_eol && !COMMENT_CONTINUATION_TYPES.include?(next_token&.type)
@@ -307,7 +309,7 @@ module Prism
                 end
               end
             when :tNL
-              next_token = next_token = lexed[index][0]
+              next_token, _ = lexed[index]
               # Newlines after comments are emitted out of order.
               if next_token&.type == :COMMENT
                 comment_newline_location = location
@@ -344,8 +346,8 @@ module Prism
               location = range(token.location.start_offset, token.location.start_offset + percent_array_leading_whitespace(value))
               value = nil
             when :tSTRING_BEG
-              next_token = lexed[index][0]
-              next_next_token = lexed[index + 1][0]
+              next_token, _ = lexed[index]
+              next_next_token, _ = lexed[index + 1]
               basic_quotes = value == '"' || value == "'"
 
               if basic_quotes && next_token&.type == :STRING_END
@@ -413,7 +415,8 @@ module Prism
                 while token.type == :STRING_CONTENT
                   current_length += token.value.bytesize
                   # Heredoc interpolation can have multiple STRING_CONTENT nodes on the same line.
-                  is_first_token_on_line = lexed[index - 1] && token.location.start_line != lexed[index - 2][0].location&.start_line
+                  prev_token, _ = lexed[index - 2] if index - 2 >= 0
+                  is_first_token_on_line = prev_token && token.location.start_line != prev_token.location.start_line
                   # The parser gem only removes indentation when the heredoc is not nested
                   not_nested = heredoc_stack.size == 1
                   if is_percent_array
@@ -423,11 +426,16 @@ module Prism
                   end
 
                   current_string << unescape_string(value, quote_stack.last)
-                  if (backslash_count = token.value[/(\\{1,})\n/, 1]&.length).nil? || backslash_count.even? || !interpolation?(quote_stack.last)
+                  relevant_backslash_count = if quote_stack.last.start_with?("%W", "%I")
+                                               0 # the last backslash escapes the newline
+                                             else
+                                               token.value[/(\\{1,})\n/, 1]&.length || 0
+                                             end
+                  if relevant_backslash_count.even? || !interpolation?(quote_stack.last)
                     tokens << [:tSTRING_CONTENT, [current_string, range(start_offset, start_offset + current_length)]]
                     break
                   end
-                  token = lexed[index][0]
+                  token, _ = lexed[index]
                   index += 1
                 end
               else
@@ -482,7 +490,7 @@ module Prism
               end
 
               if percent_array?(quote_stack.pop)
-                prev_token = lexed[index - 2][0] if index - 2 >= 0
+                prev_token, _ = lexed[index - 2] if index - 2 >= 0
                 empty = %i[PERCENT_LOWER_I PERCENT_LOWER_W PERCENT_UPPER_I PERCENT_UPPER_W].include?(prev_token&.type)
                 ends_with_whitespace = prev_token&.type == :WORDS_SEP
                 # parser always emits a space token after content in a percent array, even if no actual whitespace is present.
@@ -491,7 +499,7 @@ module Prism
                 end
               end
             when :tSYMBEG
-              if (next_token = lexed[index][0]) && next_token.type != :STRING_CONTENT && next_token.type != :EMBEXPR_BEGIN && next_token.type != :EMBVAR && next_token.type != :STRING_END
+              if (next_token = lexed[index]&.first) && next_token.type != :STRING_CONTENT && next_token.type != :EMBEXPR_BEGIN && next_token.type != :EMBVAR && next_token.type != :STRING_END
                 next_location = token.location.join(next_token.location)
                 type = :tSYMBOL
                 value = next_token.value
@@ -506,13 +514,13 @@ module Prism
                 type = :tIDENTIFIER
               end
             when :tXSTRING_BEG
-              if (next_token = lexed[index][0]) && !%i[STRING_CONTENT STRING_END EMBEXPR_BEGIN].include?(next_token.type)
+              if (next_token = lexed[index]&.first) && !%i[STRING_CONTENT STRING_END EMBEXPR_BEGIN].include?(next_token.type)
                 # self.`()
                 type = :tBACK_REF2
               end
               quote_stack.push(value)
             when :tSYMBOLS_BEG, :tQSYMBOLS_BEG, :tWORDS_BEG, :tQWORDS_BEG
-              if (next_token = lexed[index][0]) && next_token.type == :WORDS_SEP
+              if (next_token = lexed[index]&.first) && next_token.type == :WORDS_SEP
                 index += 1
               end
 
@@ -588,9 +596,9 @@ module Prism
           previous_line = -1
           result = Float::MAX
 
-          while (lexed[next_token_index] && next_token = lexed[next_token_index][0])
+          while (next_token = lexed[next_token_index]&.first)
             next_token_index += 1
-            next_next_token = lexed[next_token_index] && lexed[next_token_index][0]
+            next_next_token, _ = lexed[next_token_index]
             first_token_on_line = next_token.location.start_column == 0
 
             # String content inside nested heredocs and interpolation is ignored
@@ -761,12 +769,12 @@ module Prism
           elsif (value = scanner.scan(/M-\\?(?=[[:print:]])/))
             # \M-x where x is an ASCII printable character
             escape_read(result, scanner, control, true)
-          elsif (byte = scanner.get_byte)
+          elsif (byte = scanner.scan_byte)
             # Something else after an escape.
-            if control && byte == "?"
+            if control && byte == 0x3f # ASCII '?'
               result.append_as_bytes(escape_build(0x7f, false, meta))
             else
-              result.append_as_bytes(escape_build(byte.ord, control, meta))
+              result.append_as_bytes(escape_build(byte, control, meta))
             end
           end
         end

data/lib/prism/translation/parser.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 begin
+  required_version = ">= 3.3.7.2"
+  gem "parser", required_version
   require "parser"
 rescue LoadError
-  warn(%q{Error: Unable to load parser. Add `gem "parser"` to your Gemfile.})
+  warn(<<~MSG)
+    Error: Unable to load parser #{required_version}. \
+    Add `gem "parser"` to your Gemfile or run `bundle update parser`.
+  MSG
   exit(1)
 end
 
@@ -13,6 +19,13 @@ module Prism
     # whitequark/parser gem's syntax tree. It inherits from the base parser for
     # the parser gem, and overrides the parse* methods to parse with prism and
     # then translate.
+    #
+    # Note that this version of the parser always parses using the latest
+    # version of Ruby syntax supported by Prism. If you want specific version
+    # support, use one of the version-specific subclasses, such as
+    # `Prism::Translation::Parser34`. If you want to parse using the same
+    # version of Ruby syntax as the currently running version of Ruby, use
+    # `Prism::Translation::ParserCurrent`.
     class Parser < ::Parser::Base
       Diagnostic = ::Parser::Diagnostic # :nodoc:
       private_constant :Diagnostic
@@ -59,13 +72,19 @@ module Prism
       # should be implemented as needed.
       #
       def initialize(builder = Prism::Translation::Parser::Builder.new, parser: Prism)
+        if !builder.is_a?(Prism::Translation::Parser::Builder)
+          warn(<<~MSG, uplevel: 1, category: :deprecated)
+            [deprecation]: The builder passed to `Prism::Translation::Parser.new` is not a \
+            `Prism::Translation::Parser::Builder` subclass. This will raise in the next major version.
+          MSG
+        end
         @parser = parser
 
         super(builder)
       end
 
       def version # :nodoc:
-        34
+        35
       end
 
       # The default encoding for Ruby files is UTF-8.

data/lib/prism/translation/parser33.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   module Translation

data/lib/prism/translation/parser34.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   module Translation

data/lib/prism/translation/parser35.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# :markup: markdown
 
 module Prism
   module Translation

data/lib/prism/translation/parser_current.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+# :markup: markdown
+# typed: ignore
+
+#
+module Prism
+  module Translation
+    case RUBY_VERSION
+    when /^3\.3\./
+      ParserCurrent = Parser33
+    when /^3\.4\./
+      ParserCurrent = Parser34
+    when /^3\.5\./
+      ParserCurrent = Parser35
+    else
+      # Keep this in sync with released Ruby.
+      parser = Parser34
+      major, minor, _patch = Gem::Version.new(RUBY_VERSION).segments
+      warn "warning: `Prism::Translation::Current` is loading #{parser.name}, " \
+           "but you are running #{major}.#{minor}."
+      ParserCurrent = parser
+    end
+  end
+end