class Prism::Translation::Parser

This class is the entry-point for converting a prism syntax tree into the 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.

Public Class Methods

new (builder = Prism::Translation::Parser::Builder.new, parser: Prism)

The builder argument is used to create the parser using our custom builder class by default.

By using the :parser keyword argument, you can translate in a way that is compatible with the Parser gem using any parser.

For example, in RuboCop for Ruby LSP, the following approach can be used to improve performance by reusing a pre-parsed Prism::ParseLexResult:

class PrismPreparsed def initialize(prism_result) @prism_result = prism_result end

def parse_lex(source, **options)
  @prism_result
end

end

prism_preparsed = PrismPreparsed.new(prism_result)

Prism::Translation::Ruby34.new(builder, parser: prism_preparsed)

In an object passed to the :parser keyword argument, the parse and parse_lex methods should be implemented as needed.

Calls superclass method

# File lib/prism/translation/parser.rb, line 74
      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

Public Instance Methods

default_encoding ()

The default encoding for Ruby files is UTF-8.

# File lib/prism/translation/parser.rb, line 91
def default_encoding
  Encoding::UTF_8
end

parse (source_buffer)

Parses a source buffer and returns the AST.

# File lib/prism/translation/parser.rb, line 99
def parse(source_buffer)
  @source_buffer = source_buffer
  source = source_buffer.source

  offset_cache = build_offset_cache(source)
  result = unwrap(@parser.parse(source, **prism_options), offset_cache)

  build_ast(result.value, offset_cache)
ensure
  @source_buffer = nil
end

parse_with_comments (source_buffer)

Parses a source buffer and returns the AST and the source code comments.

# File lib/prism/translation/parser.rb, line 112
def parse_with_comments(source_buffer)
  @source_buffer = source_buffer
  source = source_buffer.source

  offset_cache = build_offset_cache(source)
  result = unwrap(@parser.parse(source, **prism_options), offset_cache)

  [
    build_ast(result.value, offset_cache),
    build_comments(result.comments, offset_cache)
  ]
ensure
  @source_buffer = nil
end

tokenize (source_buffer, recover = false)

Parses a source buffer and returns the AST, the source code comments, and the tokens emitted by the lexer.

# File lib/prism/translation/parser.rb, line 129
def tokenize(source_buffer, recover = false)
  @source_buffer = source_buffer
  source = source_buffer.source

  offset_cache = build_offset_cache(source)
  result =
    begin
      unwrap(@parser.parse_lex(source, **prism_options), offset_cache)
    rescue ::Parser::SyntaxError
      raise if !recover
    end

  program, tokens = result.value
  ast = build_ast(program, offset_cache) if result.success?

  [
    ast,
    build_comments(result.comments, offset_cache),
    build_tokens(tokens, offset_cache)
  ]
ensure
  @source_buffer = nil
end

try_declare_numparam (node)

Since prism resolves num params for us, we don’t need to support this kind of logic here.

# File lib/prism/translation/parser.rb, line 155
def try_declare_numparam(node)
  node.children[0].match?(/\A_[1-9]\z/)
end