Prism::Translation::Parser::Compiler

Class

A visitor that knows how to convert a prism syntax tree into the whitequark/parser gem’s syntax tree.

Constants

Range

Locations in the parser gem AST are generated using this class. We store a reference to its constant to make it slightly faster to look up.

Attributes

builder

Read

The Parser::Builders::Default instance that is being used to build the AST.

forwarding

Read

The types of values that can be forwarded in the current scope.

in_destructure

Read

Whether or not the current node is in a destructure.

in_pattern

Read

Whether or not the current node is in a pattern.

offset_cache

Read

The offset cache that is used to map between byte and character offsets in the file.

parser

Read

The Parser::Base instance that is being used to build the AST.

source_buffer

Read

The Parser::Source::Buffer instance that is holding a reference to the source code.

Class Methods

new(parser, offset_cache, forwarding: [], in_destructure: false, in_pattern: false)

.

Initialize a new compiler with the given parser, offset cache, and options.

Instance Methods

copy_compiler(forwarding: self.forwarding, in_destructure: self.in_destructure, in_pattern: self.in_pattern)

#

Initialize a new compiler with the given option overrides, used to visit a subtree with the given options.

find_forwarding(node)

#

When , *, &, or … are used as an argument in a method call, we check if they were allowed by the current context. To determine that we build this lookup table.

multi_target_elements(node)

#

Returns the set of targets for a MultiTargetNode or a MultiWriteNode.

numeric_negate(message_loc, receiver)

#

Negate the value of a numeric node. This is a special case where you have a negative sign on one line and then a number on the next line. In normal Ruby, this will always be a method call. The parser gem, however, marks this as a numeric literal. We have to massage the tree here to get it into the correct form.

procarg0?(parameters)

#

Blocks can have a special set of parameters that automatically expand when given arrays if they have a single required parameter and no other parameters.

srange(location)

#

Constructs a new source range from the given start and end offsets.

srange_offsets(start_offset, end_offset)

#

Constructs a new source range from the given start and end offsets.

srange_semicolon(start_offset, end_offset)

#

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.

string_nodes_from_interpolation(node, opening)

#

When the content of a string node is split across multiple lines, the parser gem creates individual string nodes for each line the content is part of.

string_nodes_from_line_continuations(unescaped, escaped, start_offset, opening)

#

Create parser string nodes from a single prism node. The parser gem “glues” strings together when a line continuation is encountered.

token(location)

#

Transform a location into a token that the parser gem expects.

visit_alias_global_variable_node(node)

#

alias $foo $bar ^^^^^^^^^^^^^^^

visit_alias_method_node(node)

#

alias foo bar ^^^^^^^^^^^^^

visit_alternation_pattern_node(node)

#

foo => bar | baz ^^^^^^^^^

visit_and_node(node)

#

a and b ^^^^^^^

visit_arguments_node(node)

#

foo(bar) ^^^

visit_array_node(node)

#

[] ^^

visit_array_pattern_node(node)

#

foo => [bar] ^^^^^

visit_assoc_node(node)

#

{ a: 1 } ^^^^

visit_assoc_splat_node(node)

#

def foo(); bar(); end ^^

{ **foo } ^^^^^

visit_back_reference_read_node(node)

#

$+ ^^

visit_begin_node(node)

#

begin end ^^^^^^^^^

visit_block(call, block)

#

Visit a block node on a call.

visit_block_argument_node(node)

#

foo(&bar) ^^^^

visit_block_local_variable_node(node)

#

foo { |; bar| } ^^^

visit_block_node(node)

#

A block on a keyword or method call.

visit_block_parameter_node(node)

#

def foo(&bar); end ^^^^

visit_block_parameters_node(node)

#

A block’s parameters.

visit_break_node(node)

#

break ^^^^^

break foo ^^^^^^^^^

visit_call_and_write_node(node)

#

foo.bar &&= baz ^^^^^^^^^^^^^^^

visit_call_node(node)

#

foo ^^^

foo.bar ^^^^^^^

foo.bar() {} ^^^^^^^^^^^^

visit_call_operator_write_node(node)

#

foo.bar += baz ^^^^^^^^^^^^^^^

visit_call_or_write_node(node)

#

foo.bar ||= baz ^^^^^^^^^^^^^^^

visit_call_target_node(node)

#

foo.bar, = 1 ^^^^^^^

visit_capture_pattern_node(node)

#

foo => bar => baz ^^^^^^^^^^

visit_case_match_node(node)

#

case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^

visit_case_node(node)

#

case foo; when bar; end ^^^^^^^^^^^^^^^^^^^^^^^

visit_class_node(node)

#

class Foo; end ^^^^^^^^^^^^^^

visit_class_variable_and_write_node(node)

#

@@foo &&= bar ^^^^^^^^^^^^^

visit_class_variable_operator_write_node(node)

#

@@foo += bar ^^^^^^^^^^^^

visit_class_variable_or_write_node(node)

#

@@foo ||= bar ^^^^^^^^^^^^^

visit_class_variable_read_node(node)

#

@@foo ^^^^^

visit_class_variable_target_node(node)

#

@@foo, = bar ^^^^^

visit_class_variable_write_node(node)

#

@@foo = 1 ^^^^^^^^^

visit_constant_and_write_node(node)

#

Foo &&= bar ^^^^^^^^^^^^

visit_constant_operator_write_node(node)

#

Foo += bar ^^^^^^^^^^^

visit_constant_or_write_node(node)

#

Foo ||= bar ^^^^^^^^^^^^

visit_constant_path_and_write_node(node)

#

Foo::Bar &&= baz ^^^^^^^^^^^^^^^^

visit_constant_path_node(node)

#

Foo::Bar ^^^^^^^^

visit_constant_path_operator_write_node(node)

#

Foo::Bar += baz ^^^^^^^^^^^^^^^

visit_constant_path_or_write_node(node)

#

Foo::Bar ||= baz ^^^^^^^^^^^^^^^^

visit_constant_path_target_node(node)

#

Foo::Bar, = baz ^^^^^^^^

visit_constant_path_write_node(node)

#

Foo::Bar = 1 ^^^^^^^^^^^^

Foo::Foo, Bar::Bar = 1 ^^^^^^^^ ^^^^^^^^

visit_constant_read_node(node)

#

Foo ^^^

visit_constant_target_node(node)

#

Foo, = bar ^^^

visit_constant_write_node(node)

#

Foo = 1 ^^^^^^^

Foo, Bar = 1 ^^^ ^^^

visit_defined_node(node)

#

defined? a ^^^^^^^^^^

defined?(a) ^^^^^^^^^^^

visit_def_node(node)

#

def foo; end ^^^^^^^^^^^^

def self.foo; end ^^^^^^^^^^^^^^^^^

visit_else_node(node)

#

if foo then bar else baz end ^^^^^^^^^^^^

visit_embedded_statements_node(node)

#

“foo #{bar}” ^^^^^^

visit_embedded_variable_node(node)

#

“foo #@bar” ^^^^^

visit_ensure_node(node)

#

begin; foo; ensure; bar; end ^^^^^^^^^^^^

visit_false_node(node)

#

false ^^^^^

visit_find_pattern_node(node)

#

foo => [, bar, ] ^^^^^^^^^^^

visit_flip_flop_node(node)

#
An alias for visit_range_node

visit_float_node(node)

#

1.0 ^^^

visit_for_node(node)

#

for foo in bar do end ^^^^^^^^^^^^^^^^^^^^^

visit_forwarding_arguments_node(node)

#

def foo(…); bar(…); end ^^^

visit_forwarding_parameter_node(node)

#

def foo(…); end ^^^

visit_forwarding_super_node(node)

#

super ^^^^^

super {} ^^^^^^^^

visit_global_variable_and_write_node(node)

#

$foo &&= bar ^^^^^^^^^^^^

visit_global_variable_operator_write_node(node)

#

$foo += bar ^^^^^^^^^^^

visit_global_variable_or_write_node(node)

#

$foo ||= bar ^^^^^^^^^^^^

visit_global_variable_read_node(node)

#

$foo ^^^^

visit_global_variable_target_node(node)

#

$foo, = bar ^^^^

visit_global_variable_write_node(node)

#

$foo = 1 ^^^^^^^^

visit_hash_node(node)

#

{} ^^

visit_hash_pattern_node(node)

#

foo => {} ^^

visit_heredoc(node) { |children, closing_t| ... }

#

Visit a heredoc that can be either a string or an xstring.

visit_if_node(node)

#

if foo then bar end ^^^^^^^^^^^^^^^^^^^

bar if foo ^^^^^^^^^^

foo ? bar : baz ^^^^^^^^^^^^^^^

visit_imaginary_node(node)

#

1i ^^

visit_implicit_node(node)

#

{ foo: } ^^^^

visit_implicit_rest_node(node)

#

foo { |bar,| } ^

visit_index_and_write_node(node)

#

foo &&= baz ^^^^^^^^^^^^^^^^

visit_index_operator_write_node(node)

#

foo += baz ^^^^^^^^^^^^^^^

visit_index_or_write_node(node)

#

foo ||= baz ^^^^^^^^^^^^^^^^

visit_index_target_node(node)

#

foo, = 1 ^^^^^^^^

visit_in_node(node)

#

case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^

visit_instance_variable_and_write_node(node)

#

@foo &&= bar ^^^^^^^^^^^^

visit_instance_variable_operator_write_node(node)

#

@foo += bar ^^^^^^^^^^^

visit_instance_variable_or_write_node(node)

#

@foo ||= bar ^^^^^^^^^^^^

visit_instance_variable_read_node(node)

#

@foo ^^^^

visit_instance_variable_target_node(node)

#

@foo, = bar ^^^^

visit_instance_variable_write_node(node)

#

@foo = 1 ^^^^^^^^

visit_integer_node(node)

#

1 ^

visit_interpolated_match_last_line_node(node)

#

visit_interpolated_regular_expression_node(node)

#

/foo #{bar}/ ^^^^^^^^^^^^

visit_interpolated_string_node(node)

#

“foo #{bar}” ^^^^^^^^^^^^

visit_interpolated_symbol_node(node)

#

:“foo #{bar}” ^^^^^^^^^^^^^

visit_interpolated_x_string_node(node)

#

foo #{bar} ^^^^^^^^^^^^

visit_it_local_variable_read_node(node)

#

-> { it } ^^

visit_it_parameters_node(node)

#

-> { it } ^^^^^^^^^

visit_keyword_hash_node(node)

#

foo(bar: baz) ^^^^^^^^

visit_keyword_rest_parameter_node(node)

#

def foo(**bar); end ^^^^^

def foo(**); end ^^

visit_lambda_node(node)

#

-> {} ^^^^^

visit_local_variable_and_write_node(node)

#

foo &&= bar ^^^^^^^^^^^

visit_local_variable_operator_write_node(node)

#

foo += bar ^^^^^^^^^^

visit_local_variable_or_write_node(node)

#

foo ||= bar ^^^^^^^^^^^

visit_local_variable_read_node(node)

#

foo ^^^

visit_local_variable_target_node(node)

#

foo, = bar ^^^

visit_local_variable_write_node(node)

#

foo = 1 ^^^^^^^

visit_match_last_line_node(node)

#

visit_match_predicate_node(node)

#

foo in bar ^^^^^^^^^^

visit_match_required_node(node)

#

foo => bar ^^^^^^^^^^

visit_match_write_node(node)

#

/(?<foo>foo)/ =~ bar ^^^^^^^^^^^^^^^^^^^^

visit_missing_node(node)

#

A node that is missing from the syntax tree. This is only used in the case of a syntax error. The parser gem doesn’t have such a concept, so we invent our own here.

visit_module_node(node)

#

module Foo; end ^^^^^^^^^^^^^^^

visit_multi_target_node(node)

#

foo, bar = baz ^^^^^^^^

visit_multi_write_node(node)

#

foo, bar = baz ^^^^^^^^^^^^^^

visit_next_node(node)

#

next ^^^^

next foo ^^^^^^^^

visit_nil_node(node)

#

nil ^^^

visit_no_keywords_parameter_node(node)

#

def foo(**nil); end ^^^^^

visit_numbered_parameters_node(node)

#

-> { 1 + 2 } ^^^^^^^^^^^^^^

visit_numbered_reference_read_node(node)

#

$1 ^^

visit_numeric(node, value)

#

Visit a numeric node and account for the optional sign.

visit_optional_keyword_parameter_node(node)

#

def foo(bar: baz); end ^^^^^^^^

visit_optional_parameter_node(node)

#

def foo(bar = 1); end ^^^^^^^

visit_or_node(node)

#

a or b ^^^^^^

visit_parameters_node(node)

#

def foo(bar, *baz); end ^^^^^^^^^

visit_parentheses_node(node)

#

() ^^

(1) ^^^

visit_pinned_expression_node(node)

#

foo => ^(bar) ^^^^^^

visit_pinned_variable_node(node)

#

foo = 1 and bar => ^foo ^^^^

visit_post_execution_node(node)

#

END {}

visit_pre_execution_node(node)

#

BEGIN {}

visit_program_node(node)

#

The top-level program node.

visit_range_node(node)

#

0..5 ^^^^

visit_rational_node(node)

#

1r ^^

visit_redo_node(node)

#

redo ^^^^

visit_regular_expression_node(node)

#

/foo/ ^^^^^

visit_required_keyword_parameter_node(node)

#

def foo(bar:); end ^^^^

visit_required_parameter_node(node)

#

def foo(bar); end ^^^

visit_rescue_modifier_node(node)

#

foo rescue bar ^^^^^^^^^^^^^^

visit_rescue_node(node)

#

begin; rescue; end ^^^^^^^

visit_rest_parameter_node(node)

#

def foo(*bar); end ^^^^

def foo(*); end ^

visit_retry_node(node)

#

retry ^^^^^

visit_return_node(node)

#

return ^^^^^^

return 1 ^^^^^^^^

visit_self_node(node)

#

self ^^^^

visit_shareable_constant_node(node)

#

A shareable constant.

visit_singleton_class_node(node)

#

class << self; end ^^^^^^^^^^^^^^^^^^

visit_source_encoding_node(node)

#

ENCODING ^^^^^^^^^^^^

visit_source_file_node(node)

#

FILE ^^^^^^^^

visit_source_line_node(node)

#

LINE ^^^^^^^^

visit_splat_node(node)

#

foo(*bar) ^^^^

def foo((bar, *baz)); end ^^^^

def foo(); bar(); end ^

visit_statements_node(node)

#

A list of statements.

visit_string_node(node)

#

“foo” ^^^^^

visit_super_node(node)

#

super(foo) ^^^^^^^^^^

visit_symbol_node(node)

#

:foo ^^^^

visit_true_node(node)

#

true ^^^^

visit_undef_node(node)

#

undef foo ^^^^^^^^^

visit_unless_node(node)

#

unless foo; bar end ^^^^^^^^^^^^^^^^^^^

bar unless foo ^^^^^^^^^^^^^^

visit_until_node(node)

#

until foo; bar end ^^^^^^^^^^^^^^^^^^

bar until foo ^^^^^^^^^^^^^

visit_when_node(node)

#

case foo; when bar; end ^^^^^^^^^^^^^

visit_while_node(node)

#

while foo; bar end ^^^^^^^^^^^^^^^^^^

bar while foo ^^^^^^^^^^^^^

visit_x_string_node(node)

#

foo ^^^^^

visit_yield_node(node)

#

yield ^^^^^

yield 1 ^^^^^^^

within_pattern() { |copy_compiler(in_pattern: true)| ... }

#

Within the given block, track that we’re within a pattern.